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

verifiers/v1/agent.py

@@ -11,7 +11,7 @@ import asyncio
 import logging
 from collections.abc import AsyncIterator, Callable, Mapping
 from contextlib import asynccontextmanager, nullcontext
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Self
 
 from verifiers.v1.clients import (
@@ -54,6 +54,27 @@ __all__ = ["Agent", "AgentConfig", "Agents", "TimeoutConfig", "make_agent"]
 logger = logging.getLogger(__name__)
 
 
+def resolve_rollout_timeouts(timeout: TimeoutConfig, task: Task) -> RolloutTimeouts:
+    """Apply an agent's stage-timeout precedence to one task."""
+    agent_timeout = (
+        timeout.rollout if timeout.rollout is not None else task.data.timeout.agent
+    )
+    return RolloutTimeouts(
+        setup=timeout.setup if timeout.setup is not None else task.data.timeout.setup,
+        agent=agent_timeout,
+        finalize=(
+            timeout.finalize
+            if timeout.finalize is not None
+            else task.data.timeout.finalize
+        ),
+        scoring=(
+            timeout.scoring
+            if timeout.scoring is not None
+            else task.data.timeout.scoring
+        ),
+    )
+
+
 def _check_borrowed_placement(
     task: Task, runtime: Runtime, base_config: RuntimeConfig
 ) -> None:
@@ -526,34 +547,15 @@ class Agent:
             runtime_config,
             tools=[*task.toolsets(task.config), *shared_tools.values()],
         )
-        # Timeout precedence: agent-level wins, else the task's, else no limit.
-        agent_timeout = (
-            self.timeout.rollout
-            if self.timeout.rollout is not None
-            else task.data.timeout.agent
-        )
+        timeouts = resolve_rollout_timeouts(self.timeout, task)
         return {
             "agent_config": self.config,
             "harness": self.harness,
             "ctx": self.ctx,
             "runtime_config": runtime_config,
-            "timeouts": RolloutTimeouts(
-                setup=(
-                    self.timeout.setup
-                    if self.timeout.setup is not None
-                    else task.data.timeout.setup
-                ),
-                agent=cap_remote_agent_timeout(agent_timeout, runtime_config, task),
-                finalize=(
-                    self.timeout.finalize
-                    if self.timeout.finalize is not None
-                    else task.data.timeout.finalize
-                ),
-                scoring=(
-                    self.timeout.scoring
-                    if self.timeout.scoring is not None
-                    else task.data.timeout.scoring
-                ),
+            "timeouts": replace(
+                timeouts,
+                agent=cap_remote_agent_timeout(timeouts.agent, runtime_config, task),
             ),
             "limits": self.limits,
             "shared_tools": shared_tools,

verifiers/v1/envs/isolated_verifier/__init__.py

@@ -0,0 +1,7 @@
+from verifiers.v1.envs.isolated_verifier.env import (
+    IsolatedVerifierEnv,
+    IsolatedVerifierEnvConfig,
+    VerifierConfig,
+)
+
+__all__ = ["IsolatedVerifierEnv", "IsolatedVerifierEnvConfig", "VerifierConfig"]

verifiers/v1/envs/isolated_verifier/env.py

@@ -0,0 +1,182 @@
+"""Deterministic task verification in a fresh runtime.
+
+One solver agent runs the task. Its task scoring is deferred, declared artifacts
+are collected after normal task finalization, and the solver runtime is destroyed.
+The task is then set up with a fresh controller in a fresh runtime, its artifacts
+are restored, and its ordinary metrics and rewards run there onto the solver's trace.
+"""
+
+import asyncio
+import copy
+import logging
+from contextlib import AsyncExitStack
+from pathlib import PurePosixPath
+from typing import Any
+
+from pydantic import Field, SerializationInfo, field_serializer
+
+import verifiers.v1 as vf
+from verifiers.v1.agent import resolve_rollout_timeouts
+from verifiers.v1.errors import TaskError, boundary
+from verifiers.v1.runtimes import Runtime, RuntimeConfig, provision_runtime
+from verifiers.v1.utils.compile import resolve_runtime_config
+from verifiers.v1.utils.decorators import invoke
+from verifiers.v1.utils.retries import backoff
+
+logger = logging.getLogger(__name__)
+
+
+class VerifierConfig(vf.BaseConfig):
+    runtime: RuntimeConfig | None = None
+    """Independent verifier placement and policy. None provisions a fresh runtime
+    equivalent to the solver's resolved task runtime."""
+    env: dict[str, str] | None = None
+    """Process environment for verifier setup and scoring. None uses the task's
+    normal runtime environment."""
+    retries: int = Field(2, ge=0)
+    """Extra fresh-runtime attempts after setup, restoration, staging, or scoring
+    failures."""
+
+    @field_serializer("runtime")
+    def serialize_runtime(
+        self, runtime: RuntimeConfig | None, info: SerializationInfo
+    ) -> dict | None:
+        """Keep an omitted image omitted across a resolved-config round trip."""
+        if runtime is None:
+            return None
+        values = runtime.model_dump(mode=info.mode)
+        if "image" not in runtime.model_fields_set:
+            values.pop("image", None)
+        return values
+
+
+class IsolatedVerifierEnvConfig(vf.EnvConfig):
+    agent: vf.AgentConfig = vf.AgentConfig()
+    """The one solver seat."""
+    verifier: VerifierConfig = VerifierConfig()
+    """The fresh verifier's runtime, process environment, and retry policy."""
+
+
+class IsolatedVerifierEnv(vf.Env[IsolatedVerifierEnvConfig]):
+    """Run one solver, then its deterministic task scoring in a fresh runtime."""
+
+    async def run(self, task: vf.Task, agents: vf.Agents) -> None:
+        if task.config.judges:
+            raise ValueError(
+                "isolated-verifier runs deterministic task metrics and rewards; "
+                "model-backed task judges are not supported"
+            )
+        self.verifier_config(task)  # Refuse an impossible verifier before solving.
+        await agents.agent.run(task.defer_scoring(), collect_artifacts=True)
+
+    def verifier_config(self, task: vf.Task) -> RuntimeConfig:
+        base = self.config.verifier.runtime or self.config.agent.runtime
+        config = resolve_runtime_config(base, task)
+        image_spec = type(base).model_fields.get("image")
+        if (
+            self.config.verifier.runtime is not None
+            and image_spec is not None
+            and "image" in base.model_fields_set
+        ):
+            config = config.model_copy(update={"image": base.image})
+        if isinstance(config, vf.SubprocessConfig):
+            raise TypeError(
+                "isolated-verifier requires a container runtime so artifacts can be "
+                "restored safely; configure the agent or verifier runtime as docker, "
+                "prime, or modal"
+            )
+        relative = [
+            artifact.source
+            for artifact in task.data.artifacts
+            if not PurePosixPath(artifact.source).is_absolute()
+        ]
+        solver = resolve_runtime_config(self.config.agent.runtime, task)
+        solver_workdir = PurePosixPath(getattr(solver, "workdir", "") or "/")
+        verifier_workdir = PurePosixPath(config.workdir)
+        if relative and solver_workdir != verifier_workdir:
+            raise ValueError(
+                "isolated-verifier cannot transfer relative artifacts "
+                f"{relative!r} between solver workdir {str(solver_workdir)!r} and "
+                f"verifier workdir {str(verifier_workdir)!r}; use matching workdirs "
+                "or absolute artifact paths"
+            )
+        return config
+
+    async def finalize(self, task: vf.Task, episode: vf.Episode) -> None:
+        solution = episode.traces[0]
+        if solution.ok:
+            graded = await self.grade(self.verifier_config(task), task, solution)
+            episode.traces[0] = graded[1]
+
+    async def stage_verifier(
+        self, task: vf.Task, solution: vf.Trace, runtime: Runtime
+    ) -> None:
+        artifacts = dict(solution.state.artifacts)
+        async with boundary(TaskError, "verifier task setup"):
+            await invoke(task.setup, {"trace": solution, "runtime": runtime})
+        await vf.restore(runtime, artifacts)
+        async with boundary(TaskError, "verifier staging"):
+            await invoke(task.stage_verifier, {"trace": solution, "runtime": runtime})
+
+    async def verify(self, task: vf.Task, solution: vf.Trace, runtime: Runtime) -> Any:
+        await task.score(solution, runtime)
+
+    async def grade(
+        self,
+        config: RuntimeConfig,
+        task: vf.Task,
+        solution: vf.Trace,
+        *,
+        scoring_timeout_covers_attempt: bool = False,
+    ) -> tuple[Any, vf.Trace]:
+        timeouts = resolve_rollout_timeouts(self.config.agent.timeout, task)
+        last: Exception | None = None
+        for attempt in range(self.config.verifier.retries + 1):
+            if attempt:
+                delay = backoff(attempt - 1)
+                logger.warning(
+                    "isolated verifier attempt %d/%d failed (%s); retrying in %.1fs",
+                    attempt,
+                    self.config.verifier.retries + 1,
+                    last,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+            try:
+                # Teardown is outside the stage deadlines: a completed score must
+                # survive a slow cleanup of the verifier runtime.
+                async with (
+                    AsyncExitStack() as boxes,
+                    asyncio.timeout(
+                        timeouts.scoring if scoring_timeout_covers_attempt else None
+                    ),
+                ):
+                    async with asyncio.timeout(timeouts.setup):
+                        # Failed setup or scoring must not alter the next attempt.
+                        # Only the successful controller and trace leave this scope.
+                        verifier_task = copy.deepcopy(task)
+                        verifier_solution = copy.deepcopy(solution)
+                        runtime = await boxes.enter_async_context(
+                            provision_runtime(
+                                config,
+                                env=(
+                                    verifier_task.runtime_env()
+                                    if self.config.verifier.env is None
+                                    else self.config.verifier.env
+                                ),
+                            )
+                        )
+                        await runtime.prepare_setup()
+                        await self.stage_verifier(
+                            verifier_task, verifier_solution, runtime
+                        )
+                        await runtime.prepare_execution([])
+                    async with asyncio.timeout(timeouts.scoring):
+                        result = await self.verify(
+                            verifier_task, verifier_solution, runtime
+                        )
+                    return result, verifier_solution
+            except Exception as error:  # noqa: BLE001 - retry the whole fresh box
+                last = error
+        assert last is not None
+        raise last

verifiers/v1/rollout.py

@@ -467,6 +467,7 @@ class Rollout:
                 if trace.timing.agent.start and not trace.timing.agent.end:
                     trace.timing.agent.end = time.time()
             if not self._failed and self._opened:
+                assert runtime is not None
                 trace.timing.finalize.start = time.time()
                 async with boundary(TaskError, "task finalize"):
                     async with asyncio.timeout(self._timeouts.finalize):

verifiers/v1/task.py

@@ -173,15 +173,36 @@ class Task(Generic[DataT, StateT, ConfigT]):
     async def finalize(self, trace: Trace, runtime: Runtime) -> None:
         return None
 
+    async def stage_verifier(self, trace: Trace, runtime: Runtime) -> None:
+        """Prepare trusted verifier-only inputs after artifacts are restored."""
+        return
+
     async def validate(self, runtime: Runtime) -> bool | None:
         """Check the ground truth, or return None when no model-free check exists."""
         return None
 
+    def defer_scoring(self) -> Self:
+        """An independent copy whose task signals are deferred.
+
+        Lifecycle hooks still run normally: in particular, ``finalize`` can prepare
+        state before declared artifacts are collected and the solver runtime is
+        destroyed. Only task metrics, rewards, and judges are skipped; harness
+        metrics remain attached to the solver trace.
+        """
+        clone = copy.deepcopy(self)
+        clone.scoring_deferred = True
+        return clone
+
+    scoring_deferred: bool = False
+
     async def score(
         self,
         trace: Trace,
         runtime: Runtime | None = None,
     ) -> None:
+        if self.scoring_deferred:
+            return
+
         def requires_runtime(fn) -> bool:
             param = inspect.signature(fn).parameters.get("runtime")
             # A defaulted runtime parameter can still be called offline with None.

verifiers/v1/tasksets/harbor/env.py

@@ -4,47 +4,30 @@ grading for tasks that declare ``[verifier].environment_mode = "separate"``.
 The default env for harbor runs (the taskset package exports it). A shared-verifier
 task runs exactly as under the single-agent env: one `agent` trace, graded in the
 box it worked in. A separate-verifier task is graded by `finalize` instead: the
-solver's declared artifacts travel (collected by its task `finalize` while its box
-is alive), a fresh box is provisioned from the task's verifier declaration,
+solver's declared artifacts travel (collected after its task `finalize` while its
+box is alive), a fresh box is provisioned from the task's verifier declaration,
 `tests/` is staged there, and the verifier's rewards land on the solver's trace.
 No second agent is involved — the verifier is the task's own `tests/test.sh`.
 """
 
-import asyncio
-import logging
-from contextlib import AsyncExitStack
-
-from pydantic import Field
-
 import verifiers.v1 as vf
-from verifiers.v1.runtimes import RuntimeConfig, provision_runtime
+from verifiers.v1.envs.isolated_verifier import (
+    IsolatedVerifierEnv,
+    IsolatedVerifierEnvConfig,
+)
+from verifiers.v1.runtimes import Runtime, RuntimeConfig
 from verifiers.v1.tasksets.harbor.taskset import (
     HarborTask,
     verifier_box_data,
 )
-from verifiers.v1.utils.artifacts import restore
 from verifiers.v1.utils.compile import resolve_runtime_config
-from verifiers.v1.utils.retries import backoff
 
-logger = logging.getLogger(__name__)
 
+class HarborEnvConfig(IsolatedVerifierEnvConfig):
+    """The Harbor solver plus its optional independent verifier runtime."""
 
-class HarborEnvConfig(vf.EnvConfig):
-    agent: vf.AgentConfig = vf.AgentConfig()
-    """The one seat — the policy under evaluation/training; pin
-    `--env.agent.harness.*` to choose its program or runtime."""
-    verifier_runtime: RuntimeConfig | None = None
-    """Where a separate-verifier task grades. None derives the grading box from
-    the solver's runtime policy; set it (e.g. `--env.verifier-runtime.type prime
-    --env.verifier-runtime.vm true`) when the verifier needs different placement
-    than the agent."""
-    verifier_retries: int = Field(2, ge=0)
-    """Extra attempts at provisioning-and-grading the separate box before the
-    episode fails. Grading is deterministic; what these retry is the
-    infrastructure around it (image pulls, provisioning)."""
 
-
-class HarborEnv(vf.Env[HarborEnvConfig]):
+class HarborEnv(IsolatedVerifierEnv, vf.Env[HarborEnvConfig]):
     async def run(self, task: vf.Task, agents: vf.Agents) -> None:
         if not isinstance(task, HarborTask):
             raise TypeError(
@@ -56,13 +39,13 @@ class HarborEnv(vf.Env[HarborEnvConfig]):
         # Resolve the verifier's box before the solve, so an impossible pairing
         # (e.g. a restricted Prime verifier without vm=true) costs nothing
         # rather than a full agent run.
-        self._verifier_config(task)
-        await agents.agent.run(task.graded_elsewhere())
+        self.verifier_config(task)
+        await agents.agent.run(task.defer_scoring(), collect_artifacts=True)
 
-    def _verifier_config(self, task: HarborTask) -> RuntimeConfig:
+    def verifier_config(self, task: HarborTask) -> RuntimeConfig:
         base = (
-            self.config.verifier_runtime
-            if self.config.verifier_runtime is not None
+            self.config.verifier.runtime
+            if self.config.verifier.runtime is not None
             else self.config.agent.runtime
         )
         return resolve_runtime_config(base, HarborTask(verifier_box_data(task.data)))
@@ -73,55 +56,27 @@ class HarborEnv(vf.Env[HarborEnvConfig]):
         Provision a fresh box from the task's verifier declaration, restore the
         solver's collected artifacts, stage `tests/`, run the verifier, and record
         its rewards (and any extra reward.json keys as metrics) on the solver's
-        trace. Infrastructure failures retry per `verifier_retries`; the last one
-        fails the episode — a grading box that can't be reached must never read
-        as reward 0."""
+        trace. Setup, restoration, staging, and scoring failures retry per
+        `verifier.retries`; the last one fails the episode."""
         if not isinstance(task, HarborTask) or task.data.verifier is None:
             return
         solution = episode.traces[0]
         if not solution.ok:
             return
         grader = HarborTask(verifier_box_data(task.data))
-        scores = await self._grade(self._verifier_config(task), grader, solution)
+        scores, solution = await self.grade(
+            self.verifier_config(task),
+            grader,
+            solution,
+            scoring_timeout_covers_attempt=True,
+        )
         items = scores.items() if isinstance(scores, dict) else [("solved", scores)]
         for name, value in items:
             solution.record_reward(name, value)
+        episode.traces[0] = solution
 
-    async def _grade(
-        self, config: RuntimeConfig, grader: HarborTask, solution: vf.Trace
+    async def verify(
+        self, task: vf.Task, solution: vf.Trace, runtime: Runtime
     ) -> float | dict[str, float]:
-        last: Exception | None = None
-        for attempt in range(self.config.verifier_retries + 1):
-            if attempt:
-                delay = backoff(attempt - 1)
-                logger.warning(
-                    "harbor verifier attempt %d/%d failed (%s); retrying in %.1fs",
-                    attempt,
-                    self.config.verifier_retries + 1,
-                    last,
-                    delay,
-                )
-                await asyncio.sleep(delay)
-            try:
-                # The scoring deadline covers provisioning and grading, but not the
-                # box's teardown: a score already in hand must not be discarded
-                # because the teardown ran out the clock.
-                async with AsyncExitStack() as boxes:
-                    async with asyncio.timeout(grader.data.timeout.scoring):
-                        box = await boxes.enter_async_context(
-                            provision_runtime(config, env=grader.runtime_env())
-                        )
-                        await box.prepare_setup()
-                        await grader.setup(box)
-                        # Artifacts first, tests second: an artifact entry pointing
-                        # into /tests must not survive staging, which wipes and
-                        # rebuilds that directory.
-                        await restore(box, solution.state.artifacts)
-                        await grader._stage_tests(box, wipe=True)
-                        await box.prepare_execution([])
-                        scores = await grader._graded(box, solution)
-                    return scores
-            except Exception as e:  # noqa: BLE001 - each attempt's failure is retried
-                last = e
-        assert last is not None
-        raise last
+        assert isinstance(task, HarborTask)
+        return await task.run_verifier(runtime, solution)

verifiers/v1/tasksets/harbor/taskset.py

@@ -16,7 +16,6 @@ otherwise build the verifier image from ``tests/Dockerfile``.
 """
 
 import asyncio
-import copy
 import hashlib
 import io
 import logging
@@ -163,6 +162,8 @@ class HarborData(TaskData):
 class HarborTask(Task[HarborData]):
     """Stage and run Harbor's verifier inside the task's live runtime."""
 
+    verifier_staged: bool = False
+
     def runtime_env(self) -> dict[str, str]:
         return resolve_env(self.data.env)
 
@@ -186,9 +187,9 @@ class HarborTask(Task[HarborData]):
                     f"{(result.stderr or result.stdout).strip()[-500:]}"
                 )
         if self.data.healthcheck is not None:
-            await self._wait_for_health(runtime, self.data.healthcheck)
+            await self.wait_for_health(runtime, self.data.healthcheck)
 
-    async def _wait_for_health(self, runtime: Runtime, healthcheck: dict) -> None:
+    async def wait_for_health(self, runtime: Runtime, healthcheck: dict) -> None:
         from harbor.environments.base import HealthcheckError
         from harbor.models.task.config import HealthcheckConfig
 
@@ -246,18 +247,15 @@ class HarborTask(Task[HarborData]):
                     f"collect hook failed (exit {result.exit_code}): "
                     f"{hook.command}\n{detail}"
                 )
-        trace.state.artifacts = await collect(runtime, self.data.artifacts)
-
-    def graded_elsewhere(self) -> "HarborTask":
-        """A copy whose `solved` records nothing here: the harbor env grades this
-        task's finished work in a separate box of the task's choosing."""
-        clone = copy.copy(self)
-        clone._graded_elsewhere = True
-        return clone
+        if not self.scoring_deferred:
+            trace.state.artifacts = await collect(runtime, self.data.artifacts)
 
-    _graded_elsewhere: bool = False
+    async def stage_verifier(self, runtime: Runtime) -> None:
+        # An artifact under /tests must not replace the task package's verifier.
+        await self.stage_tests(runtime, wipe=True)
+        self.verifier_staged = True
 
-    async def _stage_tests(self, runtime: Runtime, wipe: bool = False) -> None:
+    async def stage_tests(self, runtime: Runtime, wipe: bool = False) -> None:
         """Put the task package's `tests/` in `/tests`, where `test.sh` expects it.
 
         Raises rather than scoring stale state: a leftover reward file — planted by
@@ -286,24 +284,26 @@ class HarborTask(Task[HarborData]):
     @reward(weight=1.0)
     async def solved(self, runtime: Runtime, trace: Trace) -> float | dict[str, float]:
         if self.data.verifier is not None:
-            if not self._graded_elsewhere:
+            if not self.verifier_staged:
                 raise TaskError(
                     f"task {self.data.name!r} declares a separate verifier "
                     '([verifier].environment_mode = "separate"); grade it through '
                     "the harbor env (this taskset's default), or force shared "
                     "grading with --taskset.ignore-separate-verifier"
                 )
-            return {}
-        await self._stage_tests(runtime)
-        return await self._graded(runtime, trace)
+        else:
+            await self.stage_tests(runtime)
+        return await self.run_verifier(runtime, trace)
 
-    async def _graded(self, runtime: Runtime, trace: Trace) -> float | dict[str, float]:
+    async def run_verifier(
+        self, runtime: Runtime, trace: Trace
+    ) -> float | dict[str, float]:
         # By absolute path, in the runtime's configured workdir: Harbor execs the
         # script the same way, and scripts do grade the agent's work at `$PWD`.
         await runtime.run(
             ["bash", "/tests/test.sh"], resolve_env(self.data.verifier_env)
         )
-        scores = await self._reward_json(runtime)
+        scores = await self.read_reward_json(runtime)
         if scores is not None:
             if isinstance(scores, dict) and "reward" in scores:
                 trace.record_metrics(
@@ -325,7 +325,9 @@ class HarborTask(Task[HarborData]):
         except (SandboxError, OSError, ValueError):
             return 0.0
 
-    async def _reward_json(self, runtime: Runtime) -> float | dict[str, float] | None:
+    async def read_reward_json(
+        self, runtime: Runtime
+    ) -> float | dict[str, float] | None:
         """Read Harbor's scalar or keyed JSON reward, if it is valid.
 
         Bounded: this is a grading input, and nothing guarantees its size.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev44
+Version: 0.3.2.dev46
 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
@@ -24,6 +24,8 @@ Requires-Python: <3.14,>=3.11
 Requires-Dist: aiohttp>=3.14.1
 Requires-Dist: anthropic>=1.0.0
 Requires-Dist: gepa>=0.0.6
+Requires-Dist: h11>=0.16.0
+Requires-Dist: httpx2>=2.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: math-verify>=0.8.0
@@ -41,6 +43,7 @@ Requires-Dist: rich>=11.0.0
 Requires-Dist: tenacity>=8.5.0
 Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: uvicorn>=0.52.0
 Provides-Extra: harbor
 Requires-Dist: harbor==0.21.0; (python_full_version >= '3.12') and extra == 'harbor'
 Provides-Extra: lean

{verifiers-0.3.2.dev44.dist-info → verifiers-0.3.2.dev46.dist-info}/RECORD

@@ -1,17 +1,17 @@
 verifiers/__init__.py,sha256=yDYsckVQbUkwoh9mU_hBeCLGvS_aWgAxuoNm5LxQpDI,517
 verifiers/v1/__init__.py,sha256=qJKOsiUADKX4C1tMKsAPQXiJMo9-80FNeyPpAyRVshY,8352
-verifiers/v1/agent.py,sha256=doqKNn77Ldm1EIe-V69IwgBbMiN79FoVnvMcyZA0pNM,32223
+verifiers/v1/agent.py,sha256=h4zI924A-tLgezoGQaus9msogj1fSoC1Ugty01RFqU4,32206
 verifiers/v1/env.py,sha256=CEhzjojhg5jqbOYruUnc5U7TtgDHDSx8NiiFA0qfbt8,18234
 verifiers/v1/episode.py,sha256=Fft0R2W6INAVeJhoE9b8h7L_KQSz7XuxP4FT_XhcsUY,5741
 verifiers/v1/errors.py,sha256=uQySmCUrjDYFkBIii1vBFPiEcPFPQZ9EGpas_6HvcQI,5279
 verifiers/v1/graph.py,sha256=K6wKkoT_8TpNqPQISu2Xf0eHtAYW_KUGw0CteN5zr3c,36529
 verifiers/v1/harness.py,sha256=Yx-XCIs1HAmqv1F-nhCTDBUwAx51xQWNWgFcWL1WRTM,13777
 verifiers/v1/judge.py,sha256=uqn-djkK2_7Q3kOjkDo6ipOvV_HOvuLa9y6AoDjRux8,9618
-verifiers/v1/rollout.py,sha256=hoKGn1CbShbyjEM9PgYq8pdKgoC91VebTkBSgUHLtiE,23978
+verifiers/v1/rollout.py,sha256=FT6ZYfSqkKOFa5tm52XDTLijKxqpeLr3x2MBdLIk4xk,24021
 verifiers/v1/semantic.py,sha256=wssvBSEpY_tgzpFUADG9-N4HkDXgCZvNQ1pdf6qAsS0,4680
 verifiers/v1/session.py,sha256=xM7JJJVJACk0JfH9RAN1Ts8gJJKr2tGGRiIgQTrdieY,18692
 verifiers/v1/state.py,sha256=EckF2bWp-vV4b1jYJ9sLI5xrfGuI5spIgYYwW926toI,595
-verifiers/v1/task.py,sha256=vaVkBu00riiNU1Ke4NeeY2NQTXxOguz9d6NLe55hO_Q,11468
+verifiers/v1/task.py,sha256=9YhllEDgoHSz72-1fcYwBADl-rOzASnrSVimLheWmwI,12237
 verifiers/v1/taskset.py,sha256=fp2E0IEhL_Ybj9cegZwljfTmW27p_30zTWHFKw_kXE4,4374
 verifiers/v1/trace.py,sha256=8KCGMF2iaUNH_PypKNx--QwbSsl5dUCGeXp9Dmkm-24,29623
 verifiers/v1/types.py,sha256=PH1SxRWXOjPCgQD9aZgM18_bECvFSNQ25gkCbulmTKU,9857
@@ -68,6 +68,8 @@ verifiers/v1/envs/agentic_judge/__init__.py,sha256=LfEcRHLG_siKzhzWmODDXWSLpLgfu
 verifiers/v1/envs/agentic_judge/env.py,sha256=IZ8G8OgMI4P5JKJhXM0rrsBloWKgqUSzYiKHpqhEPDY,14639
 verifiers/v1/envs/best_of_n/__init__.py,sha256=mubASiwXMNIhnQFDccNAc7yZ0OFsOVK8hH8WIx9b2A4,119
 verifiers/v1/envs/best_of_n/env.py,sha256=KEUJBCVqblnXP_lEwm3mjGdaikBMkecz8UjOFPBhxc0,1987
+verifiers/v1/envs/isolated_verifier/__init__.py,sha256=HZxc65f87pSIPRslwTZzs0I17wGa-UMM-c-CHliwPss,214
+verifiers/v1/envs/isolated_verifier/env.py,sha256=zy0IhzCDyYpqo6pPvIFIdsJy-N_aSM_vG7qSJNFz0Wo,7983
 verifiers/v1/envs/shared_agentic_judge/__init__.py,sha256=9T4vyYAuqgZSQjqTIceghxnpauvqeW6XGhZSQDCttMA,168
 verifiers/v1/envs/single_agent/__init__.py,sha256=r0edAc_6gtHBhPzeBGVcdHZZqSdCPZnLMje6eVgyz5U,138
 verifiers/v1/envs/single_agent/env.py,sha256=lPs_a6VA7KoH1xqA3T8S32Jzb_d4zrx0_54LrqT5z1Q,1187
@@ -152,8 +154,8 @@ verifiers/v1/serve/server.py,sha256=h1B53RZBuYgRt4xmh9L6jBJ0KvCdq7wmCAa3nwkJMok,
 verifiers/v1/serve/types.py,sha256=CjZ6PWQlzSRkBG77gXfzKHnw_S_qKUm9dZSSxVgkv1w,1552
 verifiers/v1/tasksets/__init__.py,sha256=5hTKSPLXSZTgKBbeKQI7FEp06c0ZsaQfuwvrvVFLgb8,712
 verifiers/v1/tasksets/harbor/__init__.py,sha256=JxThzHFYEkuSfQbVf3pEnjordgdfe4MU-QOsSSbyovU,326
-verifiers/v1/tasksets/harbor/env.py,sha256=J3ggeLVD9Uyv0jRACsNb4jSMobpUcuT3EAqdIAd4VNI,5975
-verifiers/v1/tasksets/harbor/taskset.py,sha256=idR4Yo1UJHLwBdAloAZ00BI-SaJxr6-to1wxKvQgqvQ,32277
+verifiers/v1/tasksets/harbor/env.py,sha256=rZEh-1IaHpfsrwSOn7qTq7uV0K7cZZ28bHB7BEWQdnc,3622
+verifiers/v1/tasksets/harbor/taskset.py,sha256=4WPpsc7xIP5Fux8xM4VgEceRKxRc6lCGixRWjAwojW4,32275
 verifiers/v1/tasksets/lean/__init__.py,sha256=oyv-GbJQBvCyGwo7Ysxm2NjZW-aX4j1uDoHU0f-E7xQ,767
 verifiers/v1/tasksets/lean/scoring.py,sha256=sfzsT6MUK0zdMgAQ57_P_0CBaPHy3M7go71QMr5hDrs,10599
 verifiers/v1/tasksets/lean/taskset.py,sha256=Jax76i22G9dOAswQHiWujVbFIM_PUz5yGJI_ShR4n8Y,9238
@@ -185,8 +187,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.dev44.dist-info/METADATA,sha256=B0BGMenQq8aKxh-kAWwQ1xfbmu0Q1cXac2ZgyEefDkk,4065
-verifiers-0.3.2.dev44.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-verifiers-0.3.2.dev44.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
-verifiers-0.3.2.dev44.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev44.dist-info/RECORD,,
+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,,