verifiers 0.2.2.dev16__py3-none-any.whl → 0.2.2.dev18__py3-none-any.whl

verifiers/v1/cli/dashboard/eval.py

@@ -232,7 +232,7 @@ def Overview(config: EvalConfig) -> Table:
     grid.add_column()
     seats = config.env.agent_harnesses()
     taskset = config.env.taskset
-    env_label = taskset.name if taskset is not None else "no taskset"
+    env_label = taskset.name if taskset.id else "no taskset"
     if config.env.id:
         env_label = f"{env_name(config.env.id)}+{env_label}"
     # One seat story when every seat resolves the same way (the common case); one
@@ -254,9 +254,7 @@ def Overview(config: EvalConfig) -> Table:
     # value (or our `[...]`/`{...}` delimiters) can carry Rich markup that would otherwise be
     # parsed as styling and dropped. `id` is in the `env` row; harness `runtime.type` too (hidden
     # here), but only for the harness — `taskset.task.tools.runtime.type` has no other display.
-    if taskset is not None and (
-        taskset_over := overrides(taskset, skip=frozenset({"id"}))
-    ):
+    if taskset_over := overrides(taskset, skip=frozenset({"id"})):
         grid.add_row("taskset", escape("  ·  ".join(taskset_over)))
     for role, h in seats.items():
         if harness_over := overrides(h, skip=frozenset({"id", "runtime.type"})):

verifiers/v1/cli/eval/resume.py

@@ -4,13 +4,20 @@
 flags) and writes back into the same dir. `load` keeps the good saved rollouts and
 re-runs what's owed: missing rollouts (never written) and errored ones (dropped and
 redone).
+
+A saved rollout is matched to a selected task by content: `task_key` hashes the
+task's wire data. Tasks with identical data are interchangeable, a task whose data
+changed since the interrupted run re-runs, and nothing depends on `data.idx`. The
+legacy (v0) bridge still matches by row index (`key_of`).
 """
 
+import hashlib
 import json
 import tomllib
-from collections import defaultdict
-from collections.abc import Callable
+from collections import Counter, defaultdict
+from collections.abc import Callable, Hashable, Mapping
 from pathlib import Path
+from typing import TypeVar
 
 from pydantic_core import from_json
 
@@ -19,6 +26,30 @@ from verifiers.v1.configs.eval import EvalConfig
 from verifiers.v1.episode import Episode, WireEpisode
 from verifiers.v1.trace import WireTrace
 
+K = TypeVar("K", bound=Hashable)
+
+
+def task_key(data: Mapping) -> str:
+    """Content identity of one task's wire data — an `exclude_none` dump, the shape
+    saved rows already have on disk. `sort_keys` so field order can't split identity."""
+    return hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()
+
+
+def distribute(
+    selected_keys: list[K], owed: dict[K, int], num_rollouts: int
+) -> list[int]:
+    """Spread each key's owed rollouts over its selection instances, in order —
+    content-identical tasks are interchangeable, so any instance can absorb the
+    debt (capped at `num_rollouts` each). Returns one count per selection."""
+    remaining = dict(owed)
+    counts: list[int] = []
+    for key in selected_keys:
+        take = min(num_rollouts, remaining.get(key, 0))
+        if take:
+            remaining[key] -= take
+        counts.append(take)
+    return counts
+
 
 def split_resume(argv: list[str]) -> tuple[Path | None, list[str]]:
     """Pull `--resume <dir>` / `--resume=<dir>` out of argv, returning (dir, the other args).
@@ -51,25 +82,27 @@ def load_resume_config(resume_dir: Path) -> EvalConfig:
 
 def load(
     resume_dir: Path,
-    selected_idxs: list[int],
+    selected_keys: list[K],
     num_rollouts: int,
     complete: Callable[[Episode], bool] | None = None,
     *,
     whole_task: bool = False,
-) -> tuple[list[Episode], dict[int, int]]:
-    """Load the good saved rollouts as finished episodes and diff them against the
-    run's target: returns (kept episodes, rollouts owed per task idx). A rollout is
-    kept or redone as a unit — the episode — so a multi-trace rollout interrupted
-    mid-write is simply owed again. `complete` is the environment's keep-verdict
-    (`Env.complete`); without it (the server path) the default is
-    `episode.ok`, so an errored rollout is dropped and re-run. `whole_task` redoes
-    a partially-kept task as a unit — the legacy group-scored path, where
-    `run_group` always serves the full n. Rewrites `traces.jsonl` to just the kept
-    rows via a temp file + atomic rename, so an interrupted resume can't corrupt
-    the prior results; the resumed rollouts then append. Pre-episode files (one
-    bare trace per line) load each trace as a single-trace episode."""
+    key_of: Callable[[Mapping], K] | None = None,
+) -> tuple[list[Episode], dict[K, int]]:
+    """Load the good saved rollouts and diff them against the run's target: returns
+    (kept episodes, rollouts owed per task key). `selected_keys` is one key per
+    selected task (duplicates allowed — a key selected k times is owed up to
+    `k * num_rollouts`; spread back over the tasks with `distribute`). `key_of` maps
+    a saved row's task data to its key (default `task_key`; the legacy bridge uses
+    row indices). `complete` is the keep-verdict (default `episode.ok`); `whole_task`
+    redoes a partially-kept task whole (legacy group scoring). Rewrites
+    `traces.jsonl` to the kept rows via a temp file + atomic rename; a torn or
+    malformed row is owed again, never a crash."""
     path = resume_dir / TRACES_FILE
-    selected = set(selected_idxs)
+    targets = {
+        key: count * num_rollouts for key, count in Counter(selected_keys).items()
+    }
+    keyed = key_of if key_of is not None else task_key
 
     def parse(row: dict) -> Episode:
         if sniff_episode(row):
@@ -77,7 +110,7 @@ def load(
         return Episode.of(WireTrace.model_validate(row))
 
     verdict = complete if complete is not None else (lambda episode: episode.ok)
-    good: dict[int, list[tuple[bytes, Episode]]] = defaultdict(list)
+    good: dict[K, list[tuple[bytes, Episode]]] = defaultdict(list)
     if path.exists():
         with path.open("rb") as results:
             for line in results:
@@ -89,16 +122,16 @@ def load(
                     except ValueError:
                         row = json.loads(line)
                     # The task rides each trace; a traceless record (a failure
-                    # before any trace minted) has no idx and is owed again.
+                    # before any trace minted) has no task and is owed again.
                     if sniff_episode(row):
-                        idx = row["traces"][0]["task"]["data"]["idx"]
+                        key = keyed(row["traces"][0]["task"]["data"])
                     else:
-                        idx = row["task"]["data"]["idx"]
+                        key = keyed(row["task"]["data"])
                 except (ValueError, KeyError, IndexError, TypeError):
                     # A torn final line (the run died mid-write) or a foreign shape
                     # is not a keepable rollout — it's owed again, never a crash.
                     continue
-                if idx not in selected or len(good[idx]) >= num_rollouts:
+                if key not in targets or len(good[key]) >= targets[key]:
                     continue
                 try:
                     episode = parse(row)
@@ -106,20 +139,20 @@ def load(
                         continue
                 except Exception:  # malformed row: redo it
                     continue
-                good[idx].append(
+                good[key].append(
                     (line if line.endswith(b"\n") else line + b"\n", episode)
                 )
     keep: list[bytes] = []
     episodes: list[Episode] = []
-    owed: dict[int, int] = {}
-    for idx in selected_idxs:
-        rows = good.get(idx, [])
-        if whole_task and len(rows) < num_rollouts:
+    owed: dict[K, int] = {}
+    for key, target in targets.items():
+        rows = good.get(key, [])
+        if whole_task and len(rows) < target:
             rows = []  # a partial unit redoes whole — its kept rows are dropped
         keep.extend(line for line, _ in rows)
         episodes.extend(episode for _, episode in rows)
-        if missing := num_rollouts - len(rows):
-            owed[idx] = missing
+        if missing := target - len(rows):
+            owed[key] = missing
     tmp = path.with_suffix(".jsonl.tmp")
     tmp.write_bytes(b"".join(keep))
     tmp.replace(path)

verifiers/v1/cli/eval/runner.py

@@ -32,21 +32,25 @@ async def run_eval(env: Env, config: EvalConfig) -> list[Episode]:
         asyncio.Semaphore(config.max_concurrent) if config.max_concurrent else None
     )
     out = output_path(config)
-    owed: dict[str, int] | None = None
+    # One (task, rollouts-to-run) pair per selected task; resume shrinks the counts.
+    plan = [(task, config.num_rollouts) for task in tasks]
     # Kept on-disk rollouts rejoin the run as finished episodes; only owed ones re-run.
     finished: list[Episode] = []
     if config.resume is not None:
-        finished, owed = resume.load(
-            out, [t.data.idx for t in tasks], config.num_rollouts, env.complete
-        )
+        keys = [
+            resume.task_key(t.data.model_dump(mode="json", exclude_none=True))
+            for t in tasks
+        ]
+        finished, owed = resume.load(out, keys, config.num_rollouts, env.complete)
         if not owed:  # already complete - report it and exit successfully
             print(resume.nothing_to_resume_msg(out, len(tasks), config.num_rollouts))
             raise SystemExit(0)
-        tasks = [task for task in tasks if owed.get(task.data.idx)]
+        counts = resume.distribute(keys, owed, config.num_rollouts)
+        plan = [(task, n) for task, n in zip(tasks, counts) if n]
         logger.info(
             "resuming %s: %d task(s), %d rollout(s) owed",
             out,
-            len(tasks),
+            len(plan),
             sum(owed.values()),
         )
     else:
@@ -70,13 +74,7 @@ async def run_eval(env: Env, config: EvalConfig) -> list[Episode]:
     # Serving resources (shared tool servers, interception) come up once for the
     # run; plan slots inside so the env's agents borrow them.
     async with env.serving():
-        planned = [
-            slot
-            for task in tasks
-            for slot in env.slots(
-                task, n=owed[task.data.idx] if owed else config.num_rollouts
-            )
-        ]
+        planned = [slot for task, n in plan for slot in env.slots(task, n=n)]
         slots = [RunSlot.finished(episode) for episode in finished] + planned
         push_state = None
         if config.push and config.rich:
@@ -123,6 +121,15 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
         if legacy
         else {"config_data": env_config_data(config.env)}  # picklable across the spawn
     )
+    tasks = []
+    if not legacy:
+        from verifiers.v1.loaders import load_taskset
+
+        # The client owns the taskset: load it here, once — the server (and its pool
+        # workers) never load data, they rebuild each dispatched task from its request.
+        tasks = load_taskset(config.env.taskset).select(
+            config.num_tasks, config.shuffle
+        )
     # Spawned processes inherit no logging — hand them the main process's setup so
     # their rollout logs land in the output dir.
     level = "DEBUG" if config.verbose else "INFO"
@@ -151,48 +158,57 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
         address = await asyncio.to_thread(address_queue.get, timeout=600)
         client = EnvClient(address=address)
         await client.wait_for_server_startup(timeout=600)
-        info = await client.info()
-        # Only a legacy (v0) env group-scores; a v1 env scores siblings in its own
-        # rollout.
-        group_scored = info.requires_group_scoring
-        if info.num_tasks is None:  # infinite taskset - the run must be bounded
-            if config.num_tasks is None:
-                raise ValueError(
-                    f"{config.env_id} is infinite - bound the run with -n/--num-tasks"
-                )
-            if config.shuffle:
-                logger.warning(
-                    "shuffle is a no-op on an infinite taskset - "
-                    "taking the first %d generated tasks",
-                    config.num_tasks,
-                )
-            idxs = list(range(config.num_tasks))
-        else:
+        # A v1 run dispatches — and resumes — tasks by content: the client owns them,
+        # and `resume.task_key` is their identity. Only the legacy bridge is addressed
+        # by dataset row (its dataset lives server-side, reported via `info`), and
+        # only a legacy env group-scores; a v1 env scores siblings in its own rollout.
+        if legacy:
+            info = await client.info()
+            group_scored = info.requires_group_scoring
             idxs = sample(list(range(info.num_tasks)), config.shuffle, config.num_tasks)
+            plan = [({"task_idx": idx}, config.num_rollouts) for idx in idxs]
+        else:
+            group_scored = False
+            plan = [
+                ({"task_data": task.data.model_dump(mode="json")}, config.num_rollouts)
+                for task in tasks
+            ]
         out = output_path(config)
         finished: list[Episode] = []
         if config.resume is not None:
-            # (legacy only) a group is served and scored together, so a partially-kept
-            # task redoes as a whole group — whole_task drops its kept rows.
-            finished, owed = resume.load(
-                out, idxs, config.num_rollouts, whole_task=group_scored
-            )
+            if legacy:
+                # A group is served and scored together, so a partially-kept task
+                # redoes as a whole group — whole_task drops its kept rows.
+                finished, owed = resume.load(
+                    out,
+                    idxs,
+                    config.num_rollouts,
+                    whole_task=group_scored,
+                    key_of=lambda data: data.get("idx"),
+                )
+                counts = resume.distribute(idxs, owed, config.num_rollouts)
+            else:
+                keys = [
+                    resume.task_key(t.data.model_dump(mode="json", exclude_none=True))
+                    for t in tasks
+                ]
+                finished, owed = resume.load(out, keys, config.num_rollouts)
+                counts = resume.distribute(keys, owed, config.num_rollouts)
             if not owed:  # already complete - report it and exit successfully
-                print(resume.nothing_to_resume_msg(out, len(idxs), config.num_rollouts))
+                print(resume.nothing_to_resume_msg(out, len(plan), config.num_rollouts))
                 raise SystemExit(0)
-            idxs = [idx for idx in idxs if owed.get(idx)]
+            plan = [(payload, n) for (payload, _), n in zip(plan, counts) if n]
             logger.info(
                 "resuming %s: %d task(s), %d rollout(s) owed",
                 out,
-                len(idxs),
+                len(plan),
                 sum(owed.values()),
             )
         else:
-            owed = {idx: config.num_rollouts for idx in idxs}
             save_config(config, out)
             logger.info(
                 "running %dx%d rollouts via the env-server %s pool on %s",
-                len(idxs),
+                len(plan),
                 config.num_rollouts,
                 config.pool.type,
                 config.model,
@@ -224,13 +240,13 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
                 records.append(Episode.of(trace))
             return records
 
-        async def run_unit(idx: int) -> list[Episode]:
+        async def run_unit(payload: dict) -> list[Episode]:
             async with semaphore or contextlib.nullcontext():
                 episode = await client.run(
-                    task_idx=idx,
                     client=config.client,
                     model=config.model,
                     sampling=config.sampling,
+                    **payload,
                 )
             for trace in episode.traces:
                 trace.stamp(EvalRunInfo(id=config.uuid))
@@ -238,12 +254,12 @@ async def run_eval_server(config: EvalConfig) -> list[Episode]:
             return [episode]
 
         # A group-scored legacy task runs its rollouts together (one `run_group`
-        # request, one worker); otherwise each rollout is its own `run_rollout`
-        # request, dispatched least-busy across workers.
+        # request, one worker); otherwise each rollout is its own `run` request,
+        # dispatched least-busy across workers.
         units = (
-            [run_group_unit(i) for i in idxs]
+            [run_group_unit(payload["task_idx"]) for payload, _ in plan]
             if group_scored
-            else [run_unit(i) for i in idxs for _ in range(owed[i])]
+            else [run_unit(payload) for payload, n in plan for _ in range(n)]
         )
         results = await asyncio.gather(*units)
         await client.close()

verifiers/v1/cli/gepa.py

@@ -66,7 +66,7 @@ def main(argv: list[str] | None = None) -> None:
     # Refuse multi-agent before the dry-run return, so --dry-run can't write a
     # config the real invocation would reject.
     env_cls = vf.environment_class(
-        config.env.taskset.id if config.env.taskset is not None else "",
+        config.env.taskset.id,
         config.env.id,
     )
     if not issubclass(env_cls, vf.SingleAgentEnv):

verifiers/v1/cli/output.py

@@ -36,8 +36,8 @@ def output_path(config: EvalConfig) -> Path:
     if config.output_dir is not None:
         return config.output_dir
     taskset = config.env.taskset
-    env = taskset.name if taskset is not None else "no-taskset"
-    if taskset is not None and taskset.id and config.env.id:
+    env = taskset.name if taskset.id else "no-taskset"
+    if taskset.id and config.env.id:
         # Same compounding as `EnvConfig.env_id`: a `best-of-n+gsm8k-v1` run must
         # not share a parent dir with a plain `gsm8k-v1` one.
         env = f"{env_name(config.env.id)}+{env}"

verifiers/v1/configs/env.py

@@ -138,9 +138,7 @@ class EnvServerConfig(BaseConfig):
     @property
     def is_legacy(self) -> bool:
         """A v0/legacy env (run via the bridge): a legacy `id` is set and no v1 taskset."""
-        return self.id is not None and (
-            self.env.taskset is None or not self.env.taskset.id
-        )
+        return self.id is not None and not self.env.taskset.id
 
     @property
     def env_id(self) -> str:
@@ -152,7 +150,7 @@ class EnvServerConfig(BaseConfig):
     def _refuse_legacy_id_with_taskset(self):
         """A legacy `id` next to a v1 `env.taskset` would be silently inert
         (`is_legacy` is False and the v0 env never loads); refuse the mix."""
-        if self.id is not None and self.env.taskset is not None and self.env.taskset.id:
+        if self.id is not None and self.env.taskset.id:
             raise ValueError(
                 f"--id {self.id!r} is the legacy (v0) env id and can't combine with "
                 f"the v1 taskset {self.env.taskset.id!r}. Pairing an env with a "

verifiers/v1/env.py

@@ -31,7 +31,7 @@ from verifiers.v1.retries import RetryConfig, run_episode_with_retry
 from verifiers.v1.runtimes import SubprocessConfig, runtime_is_local
 from verifiers.v1.errors import EnvError, boundary
 from verifiers.v1.task import Task, resolve_server_config
-from verifiers.v1.taskset import Taskset, TasksetConfig
+from verifiers.v1.taskset import TasksetConfig
 from verifiers.v1.episode import Episode
 from verifiers.v1.trace import Error, Trace
 from verifiers.v1.utils.generic import deep_merge, generic_type
@@ -65,9 +65,9 @@ class EnvConfig(BaseConfig):
     """Which `Env` runs. Empty = the taskset's own, else `SingleAgentEnv`; set
     to pair a reusable env with any taskset (an explicit id wins over the bundled)."""
     # SerializeAsAny: the env-server wire needs the resolved subclass's fields.
-    taskset: SerializeAsAny[TasksetConfig] | None = None
+    taskset: SerializeAsAny[TasksetConfig] = TasksetConfig()
     """The seed taskset — the rows every rollout starts from (`--env.taskset.id`).
-    None only for an env that mints its tasks without a dataset."""
+    The id stays empty only for a legacy (v0) run, which sets the top-level `id`."""
     timeout: TimeoutConfig = TimeoutConfig()
     retries: RetryConfig = RetryConfig()
     """Whole-EPISODE retries — the coarse fallback for faults no agent owns; a
@@ -81,17 +81,14 @@ class EnvConfig(BaseConfig):
     @property
     def env_id(self) -> str:
         """The taskset id, prefixed by the paired env id (`best-of-n+gsm8k-v1`)."""
-        taskset_id = self.taskset.id if self.taskset is not None else ""
-        if taskset_id and self.id:
-            return f"{self.id}+{taskset_id}"
-        return taskset_id or self.id
+        if self.taskset.id and self.id:
+            return f"{self.id}+{self.taskset.id}"
+        return self.taskset.id or self.id
 
     def agent_harnesses(self) -> dict[str, HarnessConfig]:
         """Each declared role's resolved harness config (pin, else the taskset's
         default) — known without constructing the env."""
-        default = default_agent_harness(
-            self.taskset.id if self.taskset is not None else ""
-        )
+        default = default_agent_harness(self.taskset.id)
         return {
             name: cfg.harness if cfg.harness is not None else default
             for name, cfg in _declared_agent_configs(self).items()
@@ -239,7 +236,7 @@ class Env(ABC, Generic[ConfigT]):
                 f"{config_cls.__name__}(...) explicitly"
             )
         self.config: ConfigT = config
-        if config.taskset is None:
+        if not config.taskset.id:
             raise ValueError(
                 f"{type(self).__name__} needs a seed taskset — every rollout starts "
                 "from one of its tasks: set --env.taskset.id (or the positional "
@@ -247,7 +244,7 @@ class Env(ABC, Generic[ConfigT]):
             )
         self.taskset = load_taskset(config.taskset)
         self._default_harness = default_agent_harness(config.taskset.id)
-        task_cls = generic_type(type(self.taskset), Task, origin=Taskset) or Task
+        task_cls = type(self.taskset).task_type()
         self._task_cls: type[Task] = task_cls
         self._agent_specs: dict[str, AgentConfig] = _declared_agent_configs(self.config)
         if not self._agent_specs:
@@ -520,7 +517,7 @@ class Env(ABC, Generic[ConfigT]):
         """`requires_tunnel` over the consumers known before any rollout: role
         runtimes, live `shared` servers, and the task class's tool/user servers;
         a class overriding `server_config` conservatively counts as remote."""
-        task_cls = generic_type(type(self.taskset), Task, origin=Taskset) or Task
+        task_cls = type(self.taskset).task_type()
         server_classes = [*task_cls.tools, *([task_cls.user] if task_cls.user else [])]
         if server_classes and task_cls.server_config is not Task.server_config:
             return True

verifiers/v1/harness.py

@@ -4,6 +4,7 @@ import logging
 import os
 from abc import ABC, abstractmethod
 from collections.abc import Mapping
+from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
 
 from pydantic import Field
@@ -41,6 +42,10 @@ class HarnessConfig(BaseConfig):
     forward_env: list[str] = Field(default_factory=list)
     """Host variables to forward without writing secrets into config; explicit `env` wins."""
     disabled_tools: list[str] | None = None
+    skills: list[Path] = Field(default_factory=list)
+    """Skill folders to upload into the program's skill discovery directory — each
+    lands at `<skills dir>/<folder name>`. Only harnesses whose program discovers
+    skills natively (`SUPPORTS_SKILLS`) accept them."""
 
     @property
     def name(self) -> str:
@@ -66,6 +71,15 @@ class Harness(ABC, Generic[ConfigT]):
     every real harness; the tool-less chat loops (`null`) override to False. Read
     where model-directed execution changes the rules: the subprocess-on-host
     warning, the judge env's sandbox requirement."""
+    SUPPORTS_SKILLS: ClassVar[bool] = False
+    """Whether the program discovers SKILL.md skills — its `setup` calls
+    `install_skills` with the program's fixed discovery location; configuring
+    `skills` on a harness without support is rejected up front."""
+    NEEDS_CONTAINER: ClassVar[bool] = True
+    """Whether the program must run in a container runtime: True for every harness
+    that installs and drives a third-party program — on the host (subprocess) it
+    leaks host state (auth, config, processes) both ways. Only the minimal
+    in-house loops (`bash`, `null`) override to False."""
 
     def __init__(self, config: ConfigT) -> None:
         self.config = config
@@ -102,6 +116,28 @@ class Harness(ABC, Generic[ConfigT]):
     async def setup(self, runtime: Runtime) -> None:
         """Provision this harness in `runtime` before its execution timeout starts."""
 
+    async def install_skills(self, runtime: Runtime, dest: str) -> None:
+        """Upload each `config.skills` folder into `runtime` at `dest/<folder name>` —
+        the program's fixed skill discovery location, which a supporting harness's
+        `setup` passes."""
+        for skill in self.config.skills:
+            # Resolve so `.`/`..` entries get their real folder name (and can't
+            # place files outside `dest`).
+            skill = skill.resolve()
+            if not skill.is_dir():
+                raise ValueError(f"skill {str(skill)!r} is not a folder")
+            executables = []
+            for file in sorted(skill.rglob("*")):
+                if not file.is_file():
+                    continue
+                target = f"{dest}/{skill.name}/{file.relative_to(skill).as_posix()}"
+                await runtime.write(target, file.read_bytes())
+                if os.access(file, os.X_OK):
+                    executables.append(target)
+            if executables:
+                # `write` moves bytes, not modes; restore the execute bits scripts need.
+                await runtime.run(["chmod", "+x", *executables], {})
+
     async def run(
         self,
         ctx: ModelContext,

verifiers/v1/harnesses/bash/harness.py

@@ -41,6 +41,7 @@ class BashHarness(Harness[BashHarnessConfig]):
     SUPPORTS_MCP = True
     SUPPORTS_USER_SIM = True
     SUPPORTS_MESSAGE_PROMPT = True
+    NEEDS_CONTAINER = False
 
     async def setup(self, runtime: Runtime) -> None:
         await runtime.prepare_uv_script(PROGRAM_SOURCE, self.config.resolved_env)

verifiers/v1/harnesses/claude_code/harness.py

@@ -13,6 +13,7 @@ from verifiers.v1.trace import Trace
 CLAUDE_HOME = "/tmp/vf-claude-code-{version}"
 CLAUDE_BIN = f"{CLAUDE_HOME}/.local/bin/claude"
 CLAUDE_CONFIG_DIR = ".vf-claude"
+SKILLS_DIR = f"{CLAUDE_CONFIG_DIR}/skills"
 INSTALL = """
 set -e
 command -v curl >/dev/null || (apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null)
@@ -30,8 +31,10 @@ class ClaudeCodeHarness(Harness[ClaudeCodeHarnessConfig]):
     SUPPORTS_MCP = True
     # images would require streaming inputs
     SUPPORTS_MESSAGE_PROMPT = False
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        await self.install_skills(runtime, SKILLS_DIR)
         home = CLAUDE_HOME.format(version=self.config.version)
         binary = CLAUDE_BIN.format(version=self.config.version)
         script = INSTALL.format(version=self.config.version, home=home)
@@ -66,13 +69,13 @@ class ClaudeCodeHarness(Harness[ClaudeCodeHarnessConfig]):
             "ANTHROPIC_BASE_URL": endpoint.removesuffix("/v1"),
             "ANTHROPIC_API_KEY": secret,
             "CLAUDE_CONFIG_DIR": CLAUDE_CONFIG_DIR,
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
             "DISABLE_AUTOUPDATER": "1",
             "IS_SANDBOX": "1",
         }
         argv = [
             CLAUDE_BIN.format(version=self.config.version),
             "--print",
-            "--bare",
             "--dangerously-skip-permissions",
             "--no-session-persistence",
             "--model",

verifiers/v1/harnesses/codex/harness.py

@@ -23,6 +23,7 @@ KEY_VAR = "CODEX_INTERCEPT_KEY"
 
 CODEX_DIR = "/tmp/vf-codex"
 CODEX_BIN = f"{CODEX_DIR}/bin/codex"
+SKILLS_DIR = ".agents/skills"
 INSTALL = r"""
 set -e
 mkdir -p {dir}/bin
@@ -46,8 +47,10 @@ class CodexHarness(Harness[CodexHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = False  # TODO
     SUPPORTS_MCP = False  # TODO
     SUPPORTS_MESSAGE_PROMPT = True
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        await self.install_skills(runtime, SKILLS_DIR)
         logger.info("codex: ensuring codex %s is installed", self.config.version)
         script = (
             INSTALL.replace("{version}", self.config.version)

verifiers/v1/harnesses/kimi_code/harness.py

@@ -13,6 +13,7 @@ logger = logging.getLogger(__name__)
 
 BINARY = "/tmp/vf-kimi-code/bin/kimi"
 KIMI_HOME = ".vf-kimi-code"
+SKILLS_DIR = f"{KIMI_HOME}/skills"
 
 INSTALL = r"""
 set -e
@@ -39,8 +40,10 @@ class KimiCodeHarnessConfig(HarnessConfig):
 class KimiCodeHarness(Harness[KimiCodeHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = False
     SUPPORTS_MCP = True
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        await self.install_skills(runtime, SKILLS_DIR)
         logger.info(
             "kimi-code: ensuring Kimi Code %s is installed", self.config.version
         )

verifiers/v1/harnesses/null/harness.py

@@ -20,6 +20,7 @@ class NullHarness(Harness[NullHarnessConfig]):
     SUPPORTS_USER_SIM = True
     SUPPORTS_MESSAGE_PROMPT = True
     EXECUTES_CODE = False
+    NEEDS_CONTAINER = False
 
     async def setup(self, runtime: Runtime) -> None:
         await runtime.prepare_uv_script(PROGRAM_SOURCE, self.config.resolved_env)

verifiers/v1/harnesses/pi/harness.py

@@ -26,6 +26,7 @@ HOME_VAR = "VF_PI_ORIGINAL_HOME"
 
 PI_DIR = "/tmp/vf-pi"
 PI_BIN = f"{PI_DIR}/pi"
+SKILLS_DIR = ".agents/skills"
 MCP_VERSION = "2.11.0"
 MCP_ADAPTER = f"{PI_DIR}/mcp/node_modules/pi-mcp-adapter/index.ts"
 
@@ -95,8 +96,12 @@ class PiHarness(Harness[PiHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = True
     SUPPORTS_MCP = True
     SUPPORTS_MESSAGE_PROMPT = True
+    # Pi's project skill discovery is trust-gated (a prompt print mode can't answer),
+    # so the installed skills are passed explicitly via `--skill` at launch.
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        await self.install_skills(runtime, SKILLS_DIR)
         logger.info(
             "pi: ensuring Pi %s and pi-mcp-adapter %s are installed",
             self.config.version,
@@ -234,6 +239,12 @@ class PiHarness(Harness[PiHarnessConfig]):
             if self.config.disabled_tools
             else []
         )
+        skill_args = [
+            arg
+            for skill in self.config.skills
+            # Resolve like `install_skills` so the path matches what it wrote.
+            for arg in ("--skill", f"{SKILLS_DIR}/{skill.resolve().name}")
+        ]
         system_args = ["--append-system-prompt", system_prompt] if system_prompt else []
         argv = [
             "sh",
@@ -252,6 +263,7 @@ class PiHarness(Harness[PiHarnessConfig]):
             ctx.model,
             *mcp_args,
             *tool_args,
+            *skill_args,
             *system_args,
             *image_args,
         ]

verifiers/v1/harnesses/pool/harness.py

@@ -13,6 +13,7 @@ from verifiers.v1.types import SystemMessage, TextContentPart, UserMessage
 
 POOL_DIR = "/tmp/vf-pool-{version}"
 SETTINGS_PATH = ".poolside/settings.local.yaml"
+SKILLS_DIR = ".poolside/skills"
 INSTALL = r"""
 set -e
 command -v curl >/dev/null || (apt-get update -qq && apt-get install -y -qq curl ca-certificates >/dev/null)
@@ -35,8 +36,10 @@ class PoolHarness(Harness[PoolHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = True
     SUPPORTS_MCP = True
     SUPPORTS_MESSAGE_PROMPT = True
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        await self.install_skills(runtime, SKILLS_DIR)
         directory = POOL_DIR.format(version=self.config.version)
         binary = f"{directory}/pool"
         script = INSTALL.replace("{version}", self.config.version).replace(

verifiers/v1/harnesses/rlm/harness.py

@@ -24,6 +24,7 @@ RLM_REPO = "github.com/PrimeIntellect-ai/rlm.git"
 RLM_HOME = ".rlm"
 RLM_DIR = "/tmp/vf-rlm"
 RLM_BIN = f"{RLM_DIR}/bin/rlm"
+SKILLS_DIR = "/task/rlm-skills"
 
 
 class RLMHarnessConfig(HarnessConfig):
@@ -31,9 +32,9 @@ class RLMHarnessConfig(HarnessConfig):
     """Git ref (branch, tag, or commit) of rlm to install."""
     max_depth: int = 0
     """Recursion depth rlm may spawn sub-harnesses to (RLM_MAX_DEPTH)."""
-    skills: list[BuiltinSkill] = []
+    builtin_skills: list[BuiltinSkill] = []
     """Built-in rlm skills to enable (RLM_SKILLS), e.g. `["edit"]`; empty enables none.
-    The tool set is fixed (ipython); only built-in skills are selectable."""
+    The tool set is fixed (ipython); the base `skills` field takes SKILL.md paths."""
     summarize_at_tokens: int | tuple[int, int] | None = None
     """Auto-compaction threshold (RLM_SUMMARIZE_AT_TOKENS): compact the context once it grows
     past this many tokens. An int is a fixed threshold; a `(lo, hi)` pair draws a per-group
@@ -63,7 +64,7 @@ class RLMHarnessConfig(HarnessConfig):
         if self.disabled_tools:
             raise ValueError(
                 "the rlm harness has a fixed tool set (ipython) and does not support "
-                "`disabled_tools`; use `skills` to enable built-in skills instead."
+                "`disabled_tools`; use `builtin_skills` to enable built-in skills instead."
             )
         return self
 
@@ -71,8 +72,11 @@ class RLMHarnessConfig(HarnessConfig):
 class RLMHarness(Harness[RLMHarnessConfig]):
     APPENDS_SYSTEM_PROMPT = True
     SUPPORTS_MCP = True
+    SUPPORTS_SKILLS = True
 
     async def setup(self, runtime: Runtime) -> None:
+        # Before the installer: install.sh packages the skills it finds.
+        await self.install_skills(runtime, SKILLS_DIR)
         # install.sh fetches curl/uv itself; add git only when the image lacks it.
         install = (
             "command -v git >/dev/null 2>&1 || "
@@ -123,8 +127,8 @@ class RLMHarness(Harness[RLMHarnessConfig]):
         }
         if system_prompt is not None:
             env["RLM_APPEND_TO_SYSTEM_PROMPT"] = system_prompt
-        if self.config.skills:
-            env["RLM_SKILLS"] = ",".join(self.config.skills)
+        if self.config.builtin_skills:
+            env["RLM_SKILLS"] = ",".join(self.config.builtin_skills)
         if mcp_urls:
             env["RLM_MCP_CONFIG"] = json.dumps(
                 {"mcpServers": {name: {"url": url} for name, url in mcp_urls.items()}}

verifiers/v1/harnesses/terminus_2/harness.py

@@ -18,18 +18,10 @@ class Terminus2HarnessConfig(HarnessConfig):
 class Terminus2Harness(Harness[Terminus2HarnessConfig]):
     APPENDS_SYSTEM_PROMPT = True
     SUPPORTS_MCP = False
+    # Beyond the usual host leaks, Terminus drives tmux: on the host its tmux server —
+    # and the `tmux kill-server` cleanup in `launch` — would share the user's own.
 
     async def setup(self, runtime: Runtime) -> None:
-        # TODO: Terminus drives tmux; on the host (subprocess) runtime its tmux server — and the
-        # `tmux kill-server` cleanup in `launch` — share the host's tmux, so a host run can kill
-        # the user's own tmux session. Until tmux is isolated (a dedicated `tmux -L` socket + a
-        # created, private TMUX_TMPDIR), refuse the host runtime; run Terminus 2 in a container.
-        if runtime.type == "subprocess":
-            raise RuntimeError(
-                "Terminus 2 drives tmux and is unsafe on the subprocess (host) runtime — its tmux "
-                "cleanup can kill the host's tmux server. Run it in a container runtime "
-                "(--env.agent.harness.runtime.type docker|prime|modal)."
-            )
         source = PROGRAM_SOURCE.replace("{version}", self.config.version)
         await runtime.prepare_uv_script(source, self.config.resolved_env)
 

verifiers/v1/legacy.py

@@ -431,12 +431,23 @@ class LegacyEnvServer(EnvServer):
             state_columns=["trajectory"],
         )
 
+    @staticmethod
+    def _row(req: RunRequest) -> int:
+        """The dataset row a request addresses — the bridge's dataset lives
+        server-side, so requests must carry `task_idx` (v1 servers take `task_data`)."""
+        if req.task_idx is None:
+            raise ValueError(
+                "legacy env server requests address the dataset by task_idx"
+            )
+        return req.task_idx
+
     async def _run(self, req: RunRequest) -> RunResponse:
-        out = await self._run_v0(req.task_idx, req.client, req.model, req.sampling)
+        task_idx = self._row(req)
+        out = await self._run_v0(task_idx, req.client, req.model, req.sampling)
         # Trust the bridge-minted record; serialize it once (mirrors `EnvServer`).
         return RunResponse.model_construct(
             episode=Episode.of(
-                rollout_output_to_trace(out, req.task_idx), env=self.taskset_id
+                rollout_output_to_trace(out, task_idx), env=self.taskset_id
             )
         )
 

verifiers/v1/loaders.py

@@ -187,8 +187,7 @@ def environment_class(taskset_id: str, env_id: str = "") -> type[Env]:
 def load_environment(config: EnvConfig) -> Env:
     """Construct the env for `config`. Every construction site (eval, serve, gepa)
     goes through here so subclass envs load everywhere."""
-    taskset_id = config.taskset.id if config.taskset is not None else ""
-    return environment_class(taskset_id, config.id)(config)
+    return environment_class(config.taskset.id, config.id)(config)
 
 
 def load_taskset(config: TasksetConfig) -> Taskset:
@@ -239,8 +238,7 @@ def resolve_env_config(data: dict | EnvConfig | None) -> EnvConfig:
     validate. The one entry every consumer takes (CLI, TOML, the env-server wire),
     so role fields always validate against the real config class."""
     if isinstance(data, EnvConfig):
-        taskset_id = data.taskset.id if data.taskset is not None else ""
-        cls = env_config_type(taskset_id, data.id)
+        cls = env_config_type(data.taskset.id, data.id)
         if isinstance(data, cls):
             return data  # already at least as specifically typed — keep
         data = data.model_dump()
@@ -260,4 +258,4 @@ def resolve_env_config(data: dict | EnvConfig | None) -> EnvConfig:
 def task_type(taskset_id: str) -> type[Task]:
     """The taskset's `Task` subclass from its generic parameters — no data is
     loaded, so replay can cheaply recover the task type. Falls back to `Task`."""
-    return generic_type(taskset_class(taskset_id), Task, origin=Taskset) or Task
+    return taskset_class(taskset_id).task_type()

verifiers/v1/push.py

@@ -181,9 +181,7 @@ def push_traces(
         return finish(error="no PRIME_API_KEY (run `prime login`)")
 
     traces = [trace for episode in episodes for trace in episode.traces]
-    env_name = (
-        config.env.taskset.id if config.env.taskset is not None else ""
-    ) or config.id
+    env_name = (config.env.taskset.id) or config.id
     metrics = _run_metrics(episodes, traces)
     samples = _build_samples(episodes)
     num_examples = len({t.task.data.idx for t in traces})

verifiers/v1/serve/client.py

@@ -141,13 +141,25 @@ class EnvClient:
         return await self._request(InfoRequest(), InfoResponse)
 
     async def run(
-        self, task_idx: int, client: ClientConfig, model: str, sampling: SamplingConfig
+        self,
+        client: ClientConfig,
+        model: str,
+        sampling: SamplingConfig,
+        task_data: dict | None = None,
+        # TODO: remove task_idx addressing once v0 (the legacy bridge) is deprecated.
+        task_idx: int | None = None,
     ) -> WireEpisode:
-        """Run one rollout for `task_idx`; return its episode record — flat traces
-        (typed `Trace[WireTaskData]`) plus the shared stamp."""
+        """Run one rollout; return its episode record — flat traces (typed
+        `Trace[WireTaskData]`) plus the shared stamp. A v1 server takes the task
+        itself (`task_data`, its dumped `TaskData`); the legacy bridge addresses
+        its server-side dataset by `task_idx`."""
         response = await self._request(
             RunRequest(
-                task_idx=task_idx, client=client, model=model, sampling=sampling
+                task_data=task_data,
+                task_idx=task_idx,
+                client=client,
+                model=model,
+                sampling=sampling,
             ),
             RunResponse,
         )

verifiers/v1/serve/server.py

@@ -22,29 +22,33 @@ from verifiers.v1.serve.types import (
     RunRequest,
     RunResponse,
 )
+from verifiers.v1.task import Task, task_data_cls
 from verifiers.v1.types import SamplingConfig
 
 logger = logging.getLogger(__name__)
 
-MAX_LAZY_TASKS = 1_000_000
-"""Most tasks an infinite taskset's generator is willing to build (and cache) per worker."""
-
 
 class EnvServer:
     def __init__(
         self, config: EnvConfig, address: str = "tcp://127.0.0.1:5000"
     ) -> None:
         self.address = address
-        self.taskset_id = config.taskset.id if config.taskset is not None else ""
+        self.taskset_id = config.taskset.id
         self.env = load_environment(config)
-        # A finite taskset materializes up front; an infinite one is pulled off its
-        # generator on demand, so `num_tasks=None` on the wire means infinite.
-        self._task_iter = iter(self.env.taskset.load())
-        self._tasks: list = []
+        self.task_cls = type(self.env.taskset).task_type()
+        self.data_cls = task_data_cls(self.task_cls)
+        # A dispatched task is its client-side model_dump(): a field excluded from
+        # serialization would vanish on the wire and rebuild silently defaulted, so
+        # refuse to serve such a taskset.
+        excluded = [
+            name for name, field in self.data_cls.model_fields.items() if field.exclude
+        ]
+        if excluded:
+            raise ValueError(
+                f"{self.data_cls.__name__} excludes {excluded} from serialization — "
+                "a served task must survive the wire whole (drop exclude=True)"
+            )
         self.num_tasks: int | None = None
-        if not type(self.env.taskset).INFINITE:
-            self._tasks = list(self._task_iter)
-            self.num_tasks = len(self._tasks)
         # v1 envs never group-score (siblings score inside the env's own rollout);
         # only the legacy (v0) bridge sets this.
         self.requires_group_scoring = False
@@ -69,8 +73,8 @@ class EnvServer:
     @classmethod
     def run_server(cls, address_queue=None, **kwargs) -> None:
         """Run a spawned server and report its concrete address when requested."""
-        # Pin tqdm to a threading lock first, so the taskset load never leaks a
-        # multiprocessing semaphore (resource_tracker warning at shutdown).
+        # Pin tqdm to a threading lock first, so a dataset pull (legacy bridge) never
+        # leaks a multiprocessing semaphore (resource_tracker warning at shutdown).
         use_threading_tqdm_lock()
         server = cls(**kwargs)
         if address_queue is not None:
@@ -83,24 +87,18 @@ class EnvServer:
             # of a spurious multiprocessing traceback, matching serve_env's own handling.
             pass
 
-    def _task(self, idx: int):
-        """The task at `idx`; an infinite taskset generates (and caches) up to `idx`
-        on demand. Generation must be deterministic — every pool worker runs its own
-        `load()`, so idx-addressing relies on all producing the same sequence. The
-        `MAX_LAZY_TASKS` cap fails a runaway driver's request instead of hanging the
-        worker generating toward it."""
-        while len(self._tasks) <= idx:
-            if idx >= MAX_LAZY_TASKS:
-                raise IndexError(
-                    f"task_idx {idx} exceeds the lazy-generation cap ({MAX_LAZY_TASKS})"
-                )
-            try:
-                self._tasks.append(next(self._task_iter))
-            except StopIteration:
-                raise IndexError(
-                    f"task_idx {idx} out of range ({len(self._tasks)} tasks)"
-                ) from None
-        return self._tasks[idx]
+    def _build_task(self, task_data: dict | None) -> Task:
+        """Rebuild a request's task from its wire data: validate into the taskset's
+        declared `TaskData` type and wrap it in the declared `Task` with the config's
+        task subtree — the same construction the taskset's own `load()` performs. The
+        client owns the taskset; this server never `load()`s data, so pool workers
+        don't each pull the dataset."""
+        if task_data is None:
+            raise ValueError(
+                "v1 env server requests carry task_data (task_idx addresses the legacy bridge)"
+            )
+        data = self.data_cls.model_validate(task_data)
+        return self.task_cls(data, self.env.config.taskset.task)
 
     def _client(self, client_config: ClientConfig, model: str) -> Client:
         """Cache clients because renderer initialization builds a tokenizer pool."""
@@ -123,7 +121,7 @@ class EnvServer:
 
     async def _run(self, req: RunRequest) -> RunResponse:
         ctx = self._context(req.client, req.model, req.sampling)
-        (slot,) = self.env.slots(self._task(req.task_idx))
+        (slot,) = self.env.slots(self._build_task(req.task_data))
         # The gate spans requests: `--env.max-concurrent` bounds this worker's
         # agent runs the same way the in-process eval's semaphore does.
         episode = await self.env.run_slot(slot, ctx, self._gate)
@@ -182,7 +180,7 @@ class EnvServer:
             "EnvServer up: taskset=%s address=%s tasks=%s group_scoring=%s",
             self.taskset_id,
             self.address,
-            self.num_tasks if self.num_tasks is not None else "infinite",
+            self.num_tasks if self.num_tasks is not None else "client-side",
             self.requires_group_scoring,
         )
         poller = zmq.asyncio.Poller()

verifiers/v1/serve/types.py

@@ -1,6 +1,6 @@
 from typing import ClassVar
 
-from pydantic import BaseModel, Field, field_serializer
+from pydantic import BaseModel, Field, field_serializer, model_validator
 
 from verifiers.v1.clients.config import ClientConfig
 from verifiers.v1.task import WireTaskData
@@ -34,7 +34,9 @@ class InfoRequest(BaseRequest):
 
 class InfoResponse(BaseResponse):
     num_tasks: int | None = None
-    """Task count; `None` means the taskset is infinite (bound runs with `num_tasks`)."""
+    """Task count. Only the legacy bridge (whose dataset lives server-side) reports
+    one; a v1 server is stateless — its tasks live on the client — so this stays
+    `None`."""
     requires_group_scoring: bool = False
     """Whether tasks must be run as whole groups — legacy (v0) envs only; a v1
     server always reports False (sibling-dependent signals run inside the env's
@@ -42,12 +44,25 @@ class InfoResponse(BaseResponse):
 
 
 class RunRequest(BaseRequest):
+    """One env-rollout. v1 ships the task itself (`task_data`, the dumped `TaskData`
+    the server validates into the taskset's declared type); the legacy bridge
+    addresses its server-side dataset by row (`task_idx`)."""
+
     method: ClassVar[str] = "run"
-    task_idx: int = Field(ge=0)
+    task_data: dict | None = None
+    task_idx: int | None = Field(None, ge=0)
     client: ClientConfig
     model: str
     sampling: SamplingConfig
 
+    @model_validator(mode="after")
+    def _exactly_one(self) -> "RunRequest":
+        if (self.task_data is None) == (self.task_idx is None):
+            raise ValueError(
+                "exactly one of task_data (v1) or task_idx (legacy) must be set"
+            )
+        return self
+
 
 class RunResponse(BaseResponse):
     episode: WireEpisode | None = None

verifiers/v1/taskset.py

@@ -29,8 +29,9 @@ from pydantic import SerializeAsAny
 from pydantic_config import BaseConfig
 from typing_extensions import TypeVar
 
-from verifiers.v1.task import TaskConfig, TaskT, resolve_server_config
+from verifiers.v1.task import Task, TaskConfig, TaskT, resolve_server_config
 from verifiers.v1.types import ID
+from verifiers.v1.utils.generic import generic_type
 from verifiers.v1.utils.install import env_name
 from verifiers.v1.utils.sampling import sample
 
@@ -66,6 +67,10 @@ class Taskset(Generic[TaskT, TasksetConfigT]):
     def __init__(self, config: TasksetConfigT) -> None:
         self.config = config
 
+    @classmethod
+    def task_type(cls) -> type[Task]:
+        return generic_type(cls, Task, origin=Taskset) or Task
+
     def load(self) -> Iterable[TaskT]:
         raise NotImplementedError
 

verifiers/v1/tasksets/harbor/taskset.py

@@ -87,8 +87,8 @@ class HarborData(TaskData):
     difficulty: str | None = None
     category: str | None = None
     tags: list[str] = []
-    task_dir: str = Field("", exclude=True)
-    """Host path to the task dir; used to stage tests/ to verify, not serialized."""
+    task_dir: str = ""
+    """Host path to the task dir; used to stage tests/ to verify."""
     verifier_env: dict[str, str] = {}
     """Raw [verifier.env] entries (literals or `${VAR}`/`${VAR:-default}` templates).
     Resolved against the host environment at scoring time, like `harbor run` — so a

verifiers/v1/utils/compile.py

@@ -95,6 +95,18 @@ def validate_pairing(
             f"{task_cls.__name__} exposes tool servers (MCP). Run it with a harness that "
             f"supports MCP (e.g. --env.agent.harness.id bash), or use tasks without tools."
         )
+    if not harness.SUPPORTS_SKILLS and harness.config.skills:
+        raise ValueError(
+            f"Harness {harness.config.id!r} has no native skill support, but "
+            "`skills` is set. Run them with a harness whose program discovers "
+            "skills (e.g. --env.agent.harness.id claude-code)."
+        )
+    if harness.NEEDS_CONTAINER and isinstance(runtime_config, SubprocessConfig):
+        raise ValueError(
+            f"Harness {harness.config.id!r} needs a container runtime "
+            "(NEEDS_CONTAINER), but this run resolves to the subprocess runtime; "
+            "use --env.agent.harness.runtime.type docker or prime."
+        )
     if not harness.SUPPORTS_USER_SIM and task_cls.user is not None:
         raise ValueError(
             f"Harness {harness.config.id!r} does not drive a user simulator, but "

{verifiers-0.2.2.dev16.dist-info → verifiers-0.2.2.dev18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev16
+Version: 0.2.2.dev18
 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.2.2.dev16.dist-info → verifiers-0.2.2.dev18.dist-info}/RECORD

@@ -170,42 +170,42 @@ verifiers/utils/version_utils.py,sha256=am3hZLnlaUWTFdllGZR1VMN91hEhiiE8FDmPf1cO
 verifiers/v1/__init__.py,sha256=r8khgi7_KSY4AfevEefSslyxytScmMzzCBA6kjqvd1I,6653
 verifiers/v1/agent.py,sha256=x_n4eV4iiUPLl8OWQULrDXeMzLTLA0_GXIYJED2nJyE,21261
 verifiers/v1/decorators.py,sha256=XRMkUQSyvXCYP5fOwzBYV5qEOlxLg6rzYhnhrHHHTIQ,3838
-verifiers/v1/env.py,sha256=XQHzcTCNLmAbupkFp3edvUJqtSxs6U3mJHVz3hAI6Y4,24734
+verifiers/v1/env.py,sha256=79MMfFhQPJnLk5O96WqU_EuaVWMflz-XgiEszHvilCI,24565
 verifiers/v1/episode.py,sha256=a-8IwYecfaBAD0NPbPREQWUybx-KrgLev2JHC-shjgU,2301
 verifiers/v1/errors.py,sha256=pIn9sR12bcd-fBJhMsZjiZCWjH3Uf9Vwhfu1LakFhMY,7007
 verifiers/v1/graph.py,sha256=Mivq5jICUcyK-fhomFTwP4fQn688MXg6-hmdf03aC4Y,27703
-verifiers/v1/harness.py,sha256=dZUml8KKEPQZue7wIe8Vh7aXBCoKk_cUQeyLYyCiHdY,6541
+verifiers/v1/harness.py,sha256=2BOeYLwREgpbZbCshpGkbxHtKEFV5izLO8eT8Ay3YE0,8603
 verifiers/v1/judge.py,sha256=u15e7YXPUKi-DWhqTrwsRy0M7UTj7O0066Rwm-RAXmU,11668
-verifiers/v1/legacy.py,sha256=QlkOI5hZ--54FB2umnM1xA_OmO5J6o7jv9cxeydSbdY,21848
-verifiers/v1/loaders.py,sha256=i-cusZiJNcYQm-E8-CcEhEvtjPC5pR5nyCtlUDoNN3E,9974
-verifiers/v1/push.py,sha256=Kjsk0Z-ylJMGA5JuQJK0G44IscKO1SsZ4CcO5_Sbsjw,9385
+verifiers/v1/legacy.py,sha256=b53EDDOImu8rSaZR_ZE7jNaQTJ6aIw5T8hxlXU4fTh0,22280
+verifiers/v1/loaders.py,sha256=ISI0UKk8UXUOJke8n2M3F0EpPmqqnTgey0QDq9Ryo8I,9808
+verifiers/v1/push.py,sha256=_wRGO6UTQURSBFyPQzXSdkZGQEGZh6PyVzKNJgkyJVM,9329
 verifiers/v1/retries.py,sha256=5-LQZ2A7Tr1dpTtoJ-bX0_BrzecHm9Drf3EfQUIjVAw,6010
 verifiers/v1/rollout.py,sha256=cnVa7I98IEbIj-UmlRIe_SFZrpjJNVFnuOsQP4g4ask,16807
 verifiers/v1/scoring.py,sha256=I_mtqhTZ195hj2-CB5jzr3BY5GFKgNEvTf331f7Is4k,5740
 verifiers/v1/session.py,sha256=CyvKR1oN_UCP3SOm2vhGwn_wWlwB68GklJeFhwX5Bg8,7780
 verifiers/v1/state.py,sha256=hYo7DkOMNyh5pcKz7Xr7j-qQN2-LOKKDTlD-KdKmW40,698
 verifiers/v1/task.py,sha256=zzZsfDiulMPKorVrJHFCTYEQKagdVtAg_OlP-P0YRgk,11782
-verifiers/v1/taskset.py,sha256=L2wLzdX25ECyzspO8-TJcyGyvTjcuOXTduItOG42mPI,4209
+verifiers/v1/taskset.py,sha256=0euaEA_Bm5hFdXifdmV3fi7p0yoHofvx7w-UOExxhBo,4386
 verifiers/v1/trace.py,sha256=CnVt4lOfyzEOoXIv_XSQqhYwxY77Tu_O__FLNVFTZxs,25146
 verifiers/v1/types.py,sha256=5tZyG4r4bLJ9a14oybHy7bSCpt5X5A17eRwmIszuRo8,9118
 verifiers/v1/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/cli/debug.py,sha256=e-imOXOK1WkAkqEZqiGKsnsohDnFgm-U63sFQn_Htrg,10954
-verifiers/v1/cli/gepa.py,sha256=rYKxPiFDViH_Dcpr0ea8LHM0XQTc7itg2lH24EBH6YU,4068
+verifiers/v1/cli/gepa.py,sha256=hLIbS_4jBx0vvy4PXoePR5riFXcNvzQCMixZ-g2OR_U,4026
 verifiers/v1/cli/init.py,sha256=9rG0yjhZpKft1qhno6BI8GmpOzPlQ3r0ZBnujsevR_c,9785
-verifiers/v1/cli/output.py,sha256=sweTUDZeazNhe-DHyERyjFaW9m5Cs9XqNq2WK5zpay0,5919
+verifiers/v1/cli/output.py,sha256=878YmRnx3aMCbd6LQoTTLU88k5EC53sX9iJJgOj4jzo,5886
 verifiers/v1/cli/replay.py,sha256=d5BBrTeaun8B9BXtkOu8VCL7gnnL6tFG_zNetqsoIuM,10224
 verifiers/v1/cli/resolve.py,sha256=1sV4z04v_HEs86Oi8ODJqfujXjrbShbu3u2kDpgpj94,4079
 verifiers/v1/cli/serve.py,sha256=6rGujVxcMBso-K3fTM8EdURzw2LHshyekJfbFY5KU7A,2659
 verifiers/v1/cli/validate.py,sha256=KvOGH6cacU8nT2hX_J230VLw2q-0HEPOdIu1Wsgr8TU,9543
 verifiers/v1/cli/dashboard/__init__.py,sha256=v-baMxQuWxOCsbU7-p_jj2Q9BUnTN-TWi1q2hK6rU2s,198
 verifiers/v1/cli/dashboard/base.py,sha256=kUP93zJSIVLptSbnWX6MOy8kGg63fpeAzPqakCpPyDc,3547
-verifiers/v1/cli/dashboard/eval.py,sha256=dqLA-X4NEwQf6xcV-dEdswv_6xNqw4AxvcmTY4dTyuQ,33705
+verifiers/v1/cli/dashboard/eval.py,sha256=wQIMksQoSxqlCqXp57exRaOap-kepHzA0_6inQiSFkY,33656
 verifiers/v1/cli/dashboard/replay.py,sha256=CvRVaf0dUum5v0IzPQbFPPikBQmTrkMeaunGfVMTWHc,2755
 verifiers/v1/cli/dashboard/validate.py,sha256=7olY6oq4-zY8tvrKTJQTBwqG5ZfO5FBJ6ZHHIlKoHxo,3646
 verifiers/v1/cli/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/cli/eval/main.py,sha256=a1WzbkQP21pQJWI-AdgLCj6YB1bg4pDzVZF7OWT3WXM,5477
-verifiers/v1/cli/eval/resume.py,sha256=rUbte9oHfL9SljkDwuJGY682Uo_AI27-j6aJlha-Y2E,5822
-verifiers/v1/cli/eval/runner.py,sha256=nrAYAv18K3qUVbfb3K-8ZVioYv11lPBQnfm3352c2VY,10161
+verifiers/v1/cli/eval/resume.py,sha256=can5G76NpUdEaBZF4-lClFB09XRZ82iRoJ-7oKxrcOs,7093
+verifiers/v1/cli/eval/runner.py,sha256=IE5tiW3qjp6jtDbd92S6xMEW4UI_PRANN7oqJipuGr0,11204
 verifiers/v1/clients/__init__.py,sha256=wl1Qdx6lrPXnxvHaEip9NaUAad8i_1H6lwyWjGCCUbQ,511
 verifiers/v1/clients/client.py,sha256=9gZScQM6CVQq9RZ_3slVBEsik6tr56uOFSVNvQfMdFQ,3288
 verifiers/v1/clients/config.py,sha256=QMR0PkpFLcLi_Zw6bVimigNjNiWeJ-4YvJ_JsSS9yGw,5228
@@ -213,7 +213,7 @@ verifiers/v1/clients/eval.py,sha256=7eyc3xB489E_SWH10h42NybL3MB22W5p9Tttza__P9Q,
 verifiers/v1/clients/train.py,sha256=3y2BtL7aYeSaiknJzKh-wLHsfi54nA4pt3BBWQ3ROMs,13043
 verifiers/v1/configs/__init__.py,sha256=PlbPK0iE3vw7dqqQ-3JMdzAGiNh6sXe4p9RPhQJKRR8,345
 verifiers/v1/configs/debug.py,sha256=Z-QVPheQLu_cph_ZrCqSZI0ufkF4n0DXfvpaFTNWbHY,2831
-verifiers/v1/configs/env.py,sha256=hNfMQYEPKInnfkNhd8m0LtuvPmolQjFdEVrTZzuBEHQ,7365
+verifiers/v1/configs/env.py,sha256=GfV1_T26Fjh-XgomiGVeWmAIyIe-FjIpQ0uYKJGhBN0,7280
 verifiers/v1/configs/eval.py,sha256=nC5CmBmN3_ZoXK8QGoEiMecBRfCJxs-Qs-Nc8qZGJ_I,3808
 verifiers/v1/configs/init.py,sha256=u2Y0lKSdL9rVs2HW8qq3gIYfGNT8x8c9k355lt3Yq9A,1166
 verifiers/v1/configs/replay.py,sha256=ApH1FvuDeju-E2EHMmTsmqXu844bEPEHQbZQgAb76MM,2899
@@ -239,28 +239,28 @@ verifiers/v1/gepa/reflection.py,sha256=3wiMaXphu40i3nt38UhwNP06dMihqoVvaaBDO-52I
 verifiers/v1/gepa/runner.py,sha256=XYsXSvImrwkv6TuNtXBOEfUXfqRupHSj-VKnVYv7_3k,5374
 verifiers/v1/harnesses/__init__.py,sha256=BUIgBrFU9v8sqgPl5h6YtKHUYIpA-4xih9YhHV0zVRQ,1301
 verifiers/v1/harnesses/bash/__init__.py,sha256=IAV4eMMqDHSl-9ANb0Q3kxmBZ22SeHZFBM448X4gQio,140
-verifiers/v1/harnesses/bash/harness.py,sha256=MNRhClpeZC1E_QxdDqSYmD4_E5EweeKyVtx8YLXlF8E,5201
+verifiers/v1/harnesses/bash/harness.py,sha256=4ZWxx6dFlZEH4nLgb6NqfpSOn5LxFZsJ4U5J77clM_o,5229
 verifiers/v1/harnesses/bash/program.py,sha256=fu14BwvVEL3VJddpBC8zpZoapCWa83acAXR5XIe6SUs,15029
 verifiers/v1/harnesses/claude_code/__init__.py,sha256=JkZQylMSA3o1fvBx_NM41y_umuahmOSqFjTrJ2hryTw,171
-verifiers/v1/harnesses/claude_code/harness.py,sha256=N1tCfrCSn38zTFRHzE2psGYaM7-UxsXcH74ZveKArhY,3762
+verifiers/v1/harnesses/claude_code/harness.py,sha256=d5fZ-pyP6RdJ7AHmyUa8B4tAlwm_427i0NFAOtsyLic,3926
 verifiers/v1/harnesses/codex/__init__.py,sha256=ocyBvlpSO8c3pT6D1ebrQohoXYESQcCyPT5kN3j1-N4,132
-verifiers/v1/harnesses/codex/harness.py,sha256=Zqo7dPdYHtQeFqp_tGLWNNxTzWB8GookQdNOvpP8mSQ,7262
+verifiers/v1/harnesses/codex/harness.py,sha256=s3LA7beFu_Skp_lJsRPj2qW9VwX0uRc0sCcQcDgsfU4,7374
 verifiers/v1/harnesses/kimi_code/__init__.py,sha256=1BEotSfuzmVcE7UrxHeAREM5d7J20cGkonHuowlrzu4,161
-verifiers/v1/harnesses/kimi_code/harness.py,sha256=k0zXoEfMG4AS7yIDN6YAvuwqL8N2-RG4dSi7FG8BRs8,3527
+verifiers/v1/harnesses/kimi_code/harness.py,sha256=G6QLWBH3JdNWD_UaiT5zEmT6hXV6STmPVAj7Ir2QTlU,3644
 verifiers/v1/harnesses/mini_swe_agent/__init__.py,sha256=1OBu2Y-XqL72-dGhFdgB6sr5uX_peEEXT9vEjPy1ovU,182
 verifiers/v1/harnesses/mini_swe_agent/harness.py,sha256=wypTAvzix-7B7jMNg3JKCf2ytKmAm6_jNa5p3yGO9aA,2351
 verifiers/v1/harnesses/mini_swe_agent/program.py,sha256=XPjDEsbJACB34tkUX9dJdIziWyKnMTvAJMLevI_FFxU,159
 verifiers/v1/harnesses/null/__init__.py,sha256=XDeKOPeoXUQi9US9_Z3_yH9YaZ4EiOMKJmUtNNdtD7s,127
-verifiers/v1/harnesses/null/harness.py,sha256=awHI7O4hTEfc-7XGuWhy9b5SMfLBCfhPqjmFzn5hse4,2448
+verifiers/v1/harnesses/null/harness.py,sha256=AmfJkzHajfK3py8O5hbGT5lmsyJIMrA85NoTilCfvIk,2476
 verifiers/v1/harnesses/null/program.py,sha256=qEkzf45Oh-PlotpJxCD2nrWDf1Ocf_-b58vTerxrNzo,8357
 verifiers/v1/harnesses/pi/__init__.py,sha256=1mSnzOf-RdEchdeg6IHtcdobG5KIpAhuTdUIgsCIn74,117
-verifiers/v1/harnesses/pi/harness.py,sha256=Ns7CDiYT1w-BpKilUCBhdv85e1u-U7NwhkL2l3Y8QNk,9523
+verifiers/v1/harnesses/pi/harness.py,sha256=YjXX-RfYmzERNfC4ju9oQHYpfZWJnq2M5pAM6DCZLcM,10070
 verifiers/v1/harnesses/pool/__init__.py,sha256=HTYsNiWGdiNEsSHj4xhPmshJSNb7SHjQ7d4yZQ4p3HM,127
-verifiers/v1/harnesses/pool/harness.py,sha256=5EGHK8HiLMvJuNKk5mRT949494-kGBjjA1hqk7Kipc4,5380
+verifiers/v1/harnesses/pool/harness.py,sha256=Dui9Ov2r0qYEGAgs1lfJ-ExfLngAl3iKbmzghKmGLoo,5494
 verifiers/v1/harnesses/rlm/__init__.py,sha256=hwx51xTdEWzzYgMj-p4ETNcptoub3IPMDbEdJ4uB8Ns,122
-verifiers/v1/harnesses/rlm/harness.py,sha256=eouQp5DmH6Ni1_jPoCD0c4WQz71gyftOhbc3ydQKT94,6621
+verifiers/v1/harnesses/rlm/harness.py,sha256=83xOPXmWAQwm-4xvTyEymWvxswfLyOLf-SDQIc_poGg,6849
 verifiers/v1/harnesses/terminus_2/__init__.py,sha256=l1pwfg1HyVDEqT9efdnFWcXqaZwtKwe7TrplkyxZSA0,166
-verifiers/v1/harnesses/terminus_2/harness.py,sha256=TBnw1rGfmmvhsHi38NXYkaySpPJPxvufRomZywscz3w,3556
+verifiers/v1/harnesses/terminus_2/harness.py,sha256=JyBUrL50n0wz8--GJ_gSDiuVNTUQQdJj41w8pnGowOY,2987
 verifiers/v1/harnesses/terminus_2/program.py,sha256=DbkjUXTC_8-N05G9DJfzhGaMZQAfdTSNmf_THuKE1Zw,2606
 verifiers/v1/interception/__init__.py,sha256=SnQtCpmvc4ynIAiKDIobGVgRgss8BMTQTpZvKSygn24,2735
 verifiers/v1/interception/base.py,sha256=Riwf_qng-Gtfa4Phy2CH_HgHD4O23JaFkUpaMPc6sZw,2708
@@ -289,13 +289,13 @@ verifiers/v1/runtimes/subprocess.py,sha256=blhgfr_0YBzfxUNqiXCwMjdEUWwYW3ybebn70
 verifiers/v1/runtimes/docker/__init__.py,sha256=PoBwt7Ggd_W5TtNgUX41vPuut5_c70cQTmVWnSvSgIQ,15599
 verifiers/v1/runtimes/docker/egress.py,sha256=ELznqwFHpt1w6g4-AvoWRV_UkgvSMc5iq1DjCjvTM-k,14461
 verifiers/v1/serve/__init__.py,sha256=UDlVB8hIHIvsV4NsYUWX_icS4g67-MQI72tqMnGmZ5o,641
-verifiers/v1/serve/client.py,sha256=3zhHbAoCK6__2l8xCvZDENzSH0Ay6olHx3xtFW52eHI,6734
+verifiers/v1/serve/client.py,sha256=4R-vkhlC_49x5ofl2J_uwITc9gSNjD2fBWJ5xK4WRu8,7132
 verifiers/v1/serve/pool.py,sha256=iOOg8PfYPY0prYlHDrrVVI6efElp-lwhqmbFdYYyKE8,14716
-verifiers/v1/serve/server.py,sha256=g388bicBa6pWYv-zdgbtuqRngMCE6jZJKJOeT1qL_qA,9576
-verifiers/v1/serve/types.py,sha256=Yub1EhibbCAmuvPUAg_0L4XgvTXxWDP9YuZdn7n3uv4,2336
+verifiers/v1/serve/server.py,sha256=HoVf9xcbmD2IzIA9kgZHkxYXT8qVrWs9Uu9VKP0RmiM,9592
+verifiers/v1/serve/types.py,sha256=wXKx1AUqEax7IAk4nYYWjS9uvTgTABQW-pdmKN-kqE4,3009
 verifiers/v1/tasksets/__init__.py,sha256=E1nVxnZjtvKsw-f9sW0zui5ndMMZnjMBAMdjfE5nKfI,686
 verifiers/v1/tasksets/harbor/__init__.py,sha256=wwVGA8N7E2Q2qA5WGHuLRrn4DgG5oaRHrCS2RW3NXVY,195
-verifiers/v1/tasksets/harbor/taskset.py,sha256=keTUl54Y7syWVHziRynvT81G6lGIjpx-YBO6XBM8SkU,14593
+verifiers/v1/tasksets/harbor/taskset.py,sha256=6dPdS4NhIFDvrqEiq7-XQOpbeGF0HTtNVat50d2qX8A,14556
 verifiers/v1/tasksets/lean/__init__.py,sha256=-13Mjoj6oGpiV0hxAF9fsw9-4xWpr5MPJl7oVkcQsBA,767
 verifiers/v1/tasksets/lean/scoring.py,sha256=sfzsT6MUK0zdMgAQ57_P_0CBaPHy3M7go71QMr5hDrs,10599
 verifiers/v1/tasksets/lean/taskset.py,sha256=UsE6R9O20dgUz_0oBtvZlzrWqiAHvhtp5Y1CJZv_GEY,8988
@@ -305,7 +305,7 @@ verifiers/v1/tasksets/textarena/__init__.py,sha256=_R_E3PFP3X0lQGoedu_J9lKlB1a8t
 verifiers/v1/tasksets/textarena/taskset.py,sha256=y2OD5zwtA_rCRqpC5I8r5fJgboFDkEX_2FIQ8OYcoh4,5252
 verifiers/v1/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/utils/aio.py,sha256=ZKTHeURNbWhTpHMyYuqMLsdPWVHyn5anfG1IJs5y-Zg,1481
-verifiers/v1/utils/compile.py,sha256=dFTXzqlG2534Jg2GwrM6GHyBVbROYJayAYntzLWkFMc,5586
+verifiers/v1/utils/compile.py,sha256=uP2QUz_MiEhG4Kmb0r6LE2VqP9uH6mH-TBWXEV5Y4ok,6247
 verifiers/v1/utils/format.py,sha256=NfQo9M5KMzWCZpQaet5YtsJx56vCKAZPfbjZZJLJhhM,2187
 verifiers/v1/utils/generic.py,sha256=xwu8xNGdVOhM2K87C5cqhmnRf6apSPDASA15M0S2MaY,2054
 verifiers/v1/utils/git.py,sha256=5VX5B3011yhclPex8Mc79ZmZ5ZT4hGfKaXoqL12QMdc,4872
@@ -316,8 +316,8 @@ verifiers/v1/utils/logging.py,sha256=OcMHA6NsYux3oIzjPuI95rDWmFBHNcHDjZeNIhXTX-Y
 verifiers/v1/utils/memory.py,sha256=ZkIvGk6uITAH5sKon65LifKPbvZr8mJ__PVc23FZpOQ,1835
 verifiers/v1/utils/sampling.py,sha256=JczGzBn6s3wsIrSY2Hy3hE8m6NreNgsNzhSjDikQqX0,1037
 verifiers/v1/utils/version.py,sha256=75ZtI2NHBmlb52KpcKLUpiSXp8q4bASr7uKeXoCKlT8,1582
-verifiers-0.2.2.dev16.dist-info/METADATA,sha256=mGdtAAW0dufKathCBaYb0MM0Ir9kdzBDTJDRX0Pf8Ug,4540
-verifiers-0.2.2.dev16.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-verifiers-0.2.2.dev16.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
-verifiers-0.2.2.dev16.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.2.2.dev16.dist-info/RECORD,,
+verifiers-0.2.2.dev18.dist-info/METADATA,sha256=fW9wnVLClfpeL0usrYPdbc0cPhKZPhZp2J6oUHbbCsg,4540
+verifiers-0.2.2.dev18.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+verifiers-0.2.2.dev18.dist-info/entry_points.txt,sha256=dF82JUYEFslR1AOW8LZfuBWeZeQoyX4wCRrduklg8-I,551
+verifiers-0.2.2.dev18.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.2.2.dev18.dist-info/RECORD,,