verifiers 0.1.15.dev435__tar.gz → 0.1.15.dev437__tar.gz

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev435
+Version: 0.1.15.dev437
 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.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/ARCHITECTURE.md

@@ -69,7 +69,7 @@ several. A branch *is* a training sample: concatenating its nodes' `token_ids` r
 end to end: each surviving context window is just another root→leaf path.
 
 `Trace.to_record()` (`trace.py`) is the JSON record dump (`model_dump(mode="json")`) for
-`results.jsonl` / W&B tables, minus the per-node training tensors (`MessageNode.multi_modal_data`,
+`traces.jsonl` / W&B tables, minus the per-node training tensors (`MessageNode.multi_modal_data`,
 `routed_experts`, via `_NODE_DUMP_EXCLUDE`): those hold raw numpy bytes that can't round-trip JSON
 (the dump raises `UnicodeDecodeError` on real expert ids) and bloat every line. Computed views
 (`reward`, `branches`, `num_turns`, per-span `duration`) are pydantic properties, so they're never

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/GUIDE.md

@@ -369,7 +369,7 @@ Good to know:
 - **What lands on the trace:** the weighted verdict in `trace.rewards[<reward key>]`; rubric's
   raw per-criterion verdicts in `trace.metrics`; every call's `JudgeResponse` in
   `trace.info["judge"]` with its tokens + cost in `trace.extra_usage` (shown as `+judge` in the
-  dashboard). All persisted to `results.jsonl`.
+  dashboard). All persisted to `traces.jsonl`.
 
 Writing your own pluggable judge is the same recipe as any plugin: a package exporting a `Judge`
 subclass via `__all__` that implements `score` — declare any subset of `task` / `trace` / `runtime`
@@ -468,7 +468,7 @@ class SWETaskset(vf.Taskset[SWETask, SWEConfig]):
 `trace.info` is a free-form, **JSON-serializable** dict for per-rollout artifacts that are neither a
 reward nor a metric — the diff above, captured logs, command output, file paths. Write to it from
 `finalize` or a `@reward`/`@metric` by assigning into the dict; it is persisted with the trace
-(dumped to `results.jsonl` and sent over the wire), so every value must be JSON-serializable — a
+(dumped to `traces.jsonl` and sent over the wire), so every value must be JSON-serializable — a
 non-serializable value fails the trace dump rather than being silently dropped.
 
 ```python
@@ -815,7 +815,7 @@ client-side so each node carries the exact `token_ids` / `mask` / `logprobs` (th
 — point it at a vLLM engine with `--client.base-url`.
 
 **What it writes** (into `--output-dir`, default `outputs/<taskset>--<model>--<harness>/<uuid>`):
-`config.toml` (the resolved config, re-runnable via `@ config.toml`), `results.jsonl` (one full
+`config.toml` (the resolved config, re-runnable via `@ config.toml`), `traces.jsonl` (one full
 trace per line, appended as each rollout finishes — durable mid-run), and `eval.log`.
 
 **`--dry-run`** writes `config.toml` and exits (resolve + validate, no run). **`--resume
@@ -869,7 +869,7 @@ uv run debug swebench-v1 -n 1 --runtime.type prime --script-path ./inspect.sh
 | `--runtime.type` | `docker` | runtime for setup + the debug action |
 | `--timeout.setup` / `--timeout.total` | None | per-task wall-clock caps for `setup` and the debug action |
 | `-n`/`--num-tasks`, `-s`/`--shuffle`, `-c`/`--max-concurrent` (128) | | task selection + concurrency |
-| `-o`/`--output-dir` | fresh debug run dir | where `config.toml` and `results.jsonl` are written |
+| `-o`/`--output-dir` | fresh debug run dir | where `config.toml` and `traces.jsonl` are written |
 
 Each saved trace has command/script metadata, exit status, elapsed time, timeout/error fields,
 and the full stdout/stderr under `trace.info["debug"]`.

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/dashboard/eval.py

@@ -13,6 +13,7 @@ overview + progress sit on top, above a rule.
 
 import contextlib
 import time
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 from rich.console import Console, Group
@@ -36,6 +37,9 @@ from verifiers.v1.utils.format import (
 )
 from verifiers.utils.pricing_utils import format_cost_usd
 
+if TYPE_CHECKING:
+    from verifiers.v1.push import PushState
+
 # For sizing pages to the terminal: detects the real terminal height/width each access (the live
 # view writes to the same terminal). Reused so we don't rebuild it every refresh tick.
 _CONSOLE = Console()
@@ -208,6 +212,21 @@ def Overview(config: EvalConfig) -> Table:
     return grid
 
 
+def _push_footer(push: "PushState | None") -> Group | None:
+    """The `--push` status line under the rollouts, shown once the run finishes and the upload
+    begins: dim `Pushing traces...` while it runs, then white `Traces pushed (<url>)` or red
+    `Trace push failed (<err>)`. `None` (no line) until the upload starts and when `--push` is off."""
+    if push is None or not push.started:
+        return None
+    if not push.done:
+        line = Text("Pushing traces...", style="dim")
+    elif push.url:
+        line = Text(f"Traces pushed ({push.url})", style="white", overflow="fold")
+    else:
+        line = Text(f"Trace push failed ({push.error})", style="red", overflow="fold")
+    return Group(Rule(style="dim"), line)
+
+
 def Progress(
     rollouts: list[Rollout],
     start: float,
@@ -576,16 +595,22 @@ def _render(
     start: float,
     pager: Pager,
     finished: list[Trace] | None = None,
+    push: "PushState | None" = None,
 ) -> Group:
     now = time.time()
     warning = _warning(config)
     # `{warning}\n\n{overview}` — the caution sits at the very top, blank line, then the overview.
     header = Group(warning, Text(""), Overview(config)) if warning else Overview(config)
-    # Measure the fixed top (header + progress + rule) so the rollout rows fill the rest of the
-    # screen; page through them (timer, or the left/right arrows) when they'd overflow (rich would
-    # otherwise truncate).
+    # The --push status line appears under the rollouts once the upload starts (None during the run
+    # / when off). Measure the fixed top (header + progress + rule) and the footer so the rollout
+    # rows fill what's left; page through them (timer / arrows) when they'd overflow (else rich
+    # truncates).
+    footer = _push_footer(push)
     top = Group(header, Progress(rollouts, start, finished=finished), Rule(style="dim"))
-    rows_per_page = max(1, _CONSOLE.size.height - len(_CONSOLE.render_lines(top)) - 1)
+    reserved = len(_CONSOLE.render_lines(top))
+    if footer is not None:
+        reserved += len(_CONSOLE.render_lines(footer))
+    rows_per_page = max(1, _CONSOLE.size.height - reserved - 1)
     page_groups, index, count = _paginate(_groups(rollouts), rows_per_page, pager, now)
     progress = Progress(
         rollouts,
@@ -593,12 +618,15 @@ def _render(
         page=(index + 1, count) if count > 1 else None,
         finished=finished,
     )
-    return Group(
+    parts = [
         header,
         progress,
         Rule(style="dim"),
         Rows(page_groups, now, config.harness.runtime.type),
-    )
+    ]
+    if footer is not None:
+        parts.append(footer)
+    return Group(*parts)
 
 
 @contextlib.asynccontextmanager
@@ -607,13 +635,17 @@ async def dashboard(
     config: EvalConfig,
     start: float,
     finished: list[Trace] | None = None,
+    push: "PushState | None" = None,
 ):
     """Refresh the live eval view until the `with` block exits, then a final frame. Left/right
     arrows page through rollout rows when they overflow the screen. On resume, `finished` carries
     the kept on-disk rollouts (reloaded as finished traces) so the counts and scores cover the
-    whole run, not just this session's re-run rollouts."""
+    whole run, not just this session's re-run rollouts. `push` is the shared `--push` status the
+    view renders as a line under the rollouts once the upload starts (dim -> white URL / red error),
+    updated by the caller as the inline upload runs and lands."""
     pager = Pager()
     async with live_view(
-        lambda: _render(rollouts, config, start, pager, finished), on_key=pager.on_key
+        lambda: _render(rollouts, config, start, pager, finished, push),
+        on_key=pager.on_key,
     ):
         yield

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/eval/main.py

@@ -105,6 +105,10 @@ def main(argv: list[str] | None = None) -> None:
     else:  # in-process (default), with or without the live dashboard
         env = vf.Environment(config)
         traces = asyncio.run(run_eval(env, config))
+    if config.push and not rich:
+        from verifiers.v1.push import push_traces
+
+        push_traces(traces, config)
     if not rich:  # --rich is the whole output; otherwise dump each trace as JSON
         for trace in traces:
             print(trace.model_dump_json(indent=2, exclude_none=True))

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/eval/resume.py

@@ -1,6 +1,6 @@
 """Resume an interrupted eval: re-run only the rollouts a previous run didn't finish.
 
-A run writes `config.toml` + `results.jsonl` into its output dir. `--resume <dir>` reloads
+A run writes `config.toml` + `traces.jsonl` into its output dir. `--resume <dir>` reloads
 that config verbatim (so it takes no other flags) and writes back into the same dir, running
 only the rollouts still owed: the *missing* ones (never written — the run was interrupted) and
 the *errored* ones (written with an error). Good rollouts are kept; errored ones are dropped
@@ -16,7 +16,7 @@ from pathlib import Path
 
 from pydantic_core import from_json
 
-from verifiers.v1.cli.output import read_traces
+from verifiers.v1.cli.output import CONFIG_FILE, TRACES_FILE, read_traces
 from verifiers.v1.configs.eval import EvalConfig
 from verifiers.v1.state import state_cls
 from verifiers.v1.task import WireTask
@@ -41,8 +41,8 @@ def split_resume(argv: list[str]) -> tuple[Path | None, list[str]]:
 
 def load_resume_config(resume_dir: Path) -> EvalConfig:
     """Rebuild the run's `EvalConfig` from its saved `config.toml`, pointed back at its own
-    output dir so the resumed rollouts append to the same `results.jsonl`."""
-    config_path = resume_dir / "config.toml"
+    output dir so the resumed rollouts append to the same `traces.jsonl`."""
+    config_path = resume_dir / CONFIG_FILE
     if not config_path.exists():
         raise SystemExit(
             f"--resume: no config.toml in {resume_dir} - not an eval output dir"
@@ -81,7 +81,7 @@ def plan(
     # Retain only the offsets resume can reuse; trace payloads stay on disk.
     selected = set(selected_idxs)
     by_idx: dict[int, list[int]] = defaultdict(list)
-    for offset, idx, errored in _read_results(resume_dir / "results.jsonl"):
+    for offset, idx, errored in _read_results(resume_dir / TRACES_FILE):
         if idx in selected and not errored and len(by_idx[idx]) < num_rollouts:
             by_idx[idx].append(offset)
     keep: list[int] = []
@@ -102,9 +102,9 @@ def plan(
 
 
 def rewrite_results(resume_dir: Path, keep: list[int]) -> None:
-    """Replace `results.jsonl` with just the kept (good) traces; resumed rollouts append. Via a
+    """Replace `traces.jsonl` with just the kept (good) traces; resumed rollouts append. Via a
     temp file + atomic rename, so an interrupted resume can't corrupt the prior good results."""
-    path = resume_dir / "results.jsonl"
+    path = resume_dir / TRACES_FILE
     tmp = path.with_suffix(".jsonl.tmp")
     if not keep:
         tmp.write_bytes(b"")

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/eval/runner.py

@@ -89,8 +89,17 @@ async def run_eval(env: Environment, config: EvalConfig) -> list[Trace]:
             for task in tasks
         ]
         rollouts = [rollout for episode in episodes for rollout in episode.rollouts]
+        # --push in the live dashboard: share a status the dashboard renders as a line under the
+        # rollouts once the run finishes and the upload begins (dim -> green URL / red error), and
+        # do the upload inline below so it resolves on screen. Only the rich path has a dashboard;
+        # every other path uploads (+ logs the URL) from `main`.
+        push_state = None
+        if config.push and config.rich:
+            from verifiers.v1.push import PushState
+
+            push_state = PushState()
         display = (
-            dashboard(rollouts, config, start, finished=finished)
+            dashboard(rollouts, config, start, finished=finished, push=push_state)
             if config.rich
             else contextlib.nullcontext()
         )
@@ -98,7 +107,14 @@ async def run_eval(env: Environment, config: EvalConfig) -> list[Trace]:
             results = await asyncio.gather(
                 *(episode.run(semaphore, on_complete) for episode in episodes)
             )
-    traces = [trace for episode_traces in results for trace in episode_traces]
+            traces = [trace for episode_traces in results for trace in episode_traces]
+            if (
+                push_state is not None
+            ):  # upload off the event loop so the view keeps refreshing
+                from verifiers.v1.push import push_traces
+
+                push_state.started = True
+                await asyncio.to_thread(push_traces, traces, config, push_state)
     await client.close()
     return traces
 
@@ -107,7 +123,7 @@ async def run_eval_server(config: EvalConfig) -> list[Trace]:
     """Eval through the env-server worker pool (`--num-workers > 0`). Spawns the pool
     (works for v1 and the v0 bridge), then drives rollouts by task idx over an
     `EnvClient` — the same path prime-rl trains through, so it exercises the
-    router + workers end-to-end. Output matches `run_eval` (config.toml + results.jsonl)."""
+    router + workers end-to-end. Output matches `run_eval` (config.toml + traces.jsonl)."""
     import multiprocessing as mp
     from functools import partial
 

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/output.py

@@ -1,4 +1,4 @@
-"""On-disk output: results.jsonl (one full trace per line) + config.toml.
+"""On-disk output: traces.jsonl (one full trace per line) + config.toml.
 
 The trace is the full data dump — written verbatim, consumed by the platform
 (visualization) and prime-rl (training). config.toml is the run's resolved EvalConfig,
@@ -7,7 +7,7 @@ its own output. Aggregates (avg reward, etc.) are cheap to recompute from result
 they aren't stored.
 
 The runner writes `config.toml` once up front (`save_config`) and then appends each
-trace to `results.jsonl` as it completes (`append_trace`), so a long run's results are
+trace to `traces.jsonl` as it completes (`append_trace`), so a long run's results are
 durable as they land rather than only at the end.
 """
 
@@ -22,6 +22,12 @@ from verifiers.v1.configs.eval import EvalConfig
 from verifiers.v1.trace import Trace
 from verifiers.v1.utils.aio import run_shielded
 
+TRACES_FILE = "traces.jsonl"
+"""Filename each run's full per-rollout traces are written to (one JSON trace per line)."""
+
+CONFIG_FILE = "config.toml"
+"""Filename a run's resolved config is written to (re-runnable via `@ config.toml`)."""
+
 
 def output_path(config: EvalConfig) -> Path:
     """Where this run writes: `outputs/<taskset>--<model>--<harness>/<uuid>` (or the explicit
@@ -38,35 +44,33 @@ def write_config(config: BaseModel, results_dir: Path) -> Path:
     nulls TOML can't represent."""
     results_dir.mkdir(parents=True, exist_ok=True)
     toml = tomli_w.dumps(config.model_dump(mode="json", exclude_none=True))
-    config_path = results_dir / "config.toml"
+    config_path = results_dir / CONFIG_FILE
     config_path.write_text(toml)
     return config_path
 
 
 def save_config(config: BaseModel, results_dir: Path) -> None:
     """Set up the run's output dir: write `config.toml` and start a fresh (empty)
-    `results.jsonl`. Call once up front, before traces start landing."""
+    `traces.jsonl`. Call once up front, before traces start landing."""
     write_config(config, results_dir)
-    (results_dir / "results.jsonl").write_text(
-        ""
-    )  # fresh; appended to as traces complete
+    (results_dir / TRACES_FILE).write_text("")  # fresh; appended to as traces complete
 
 
 def write_trace(results_dir: Path, trace: Trace) -> None:
     """Serialize and append one trace in the worker thread."""
     data = TypeAdapter(type(trace)).dump_json(trace, exclude_none=True)
-    with (results_dir / "results.jsonl").open("ab") as f:
+    with (results_dir / TRACES_FILE).open("ab") as f:
         f.write(data + b"\n")
 
 
 def read_traces(results_dir: Path, trace_type: type) -> list[Trace]:
-    """Load a run's saved traces from `results.jsonl`, typed as `trace_type` — the inverse of
+    """Load a run's saved traces from `traces.jsonl`, typed as `trace_type` — the inverse of
     `write_trace`. Used by `replay` to re-score finished rollouts (pass the taskset's typed
     `Trace[...]`, or `Trace[WireTask, ...]` to read any taskset's traces without importing it).
-    Streams line-by-line so a large (multi-GB) results file isn't loaded into memory at once."""
+    Streams line-by-line so a large (multi-GB) traces file isn't loaded into memory at once."""
     adapter = TypeAdapter(trace_type)
     traces: list[Trace] = []
-    with (results_dir / "results.jsonl").open(encoding="utf-8") as f:
+    with (results_dir / TRACES_FILE).open(encoding="utf-8") as f:
         for line in f:
             if line.strip():
                 traces.append(adapter.validate_python(json.loads(line)))

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/cli/replay.py

@@ -23,7 +23,13 @@ from pydantic_config import cli
 
 import verifiers.v1 as vf
 from verifiers.v1.cli.dashboard.replay import ReplayProgress, replay_dashboard
-from verifiers.v1.cli.output import append_trace, read_traces, save_config, write_config
+from verifiers.v1.cli.output import (
+    CONFIG_FILE,
+    append_trace,
+    read_traces,
+    save_config,
+    write_config,
+)
 from verifiers.v1.configs.replay import ReplayConfig
 from verifiers.v1.state import state_cls
 from verifiers.v1.task import WireTask
@@ -138,7 +144,7 @@ def main(argv: list[str] | None = None) -> None:
         cli(ReplayConfig)  # full, typed pydantic-config option help
         return
     source = Path(argv.pop(0))  # the finished run dir to replay
-    config_path = source / "config.toml"
+    config_path = source / CONFIG_FILE
     if not config_path.exists():
         raise SystemExit(f"{USAGE}\nno config.toml in {source}")
 

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/configs/debug.py

@@ -46,7 +46,7 @@ class DebugConfig(BaseConfig):
     output_dir: Path | None = Field(
         None, validation_alias=AliasChoices("output_dir", "o")
     )
-    """Where to write `config.toml` and `results.jsonl`. None = a fresh per-run dir."""
+    """Where to write `config.toml` and `traces.jsonl`. None = a fresh per-run dir."""
 
     @property
     def name(self) -> str:

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/configs/eval.py

@@ -54,10 +54,14 @@ class EvalConfig(EnvServerConfig):
     server: bool = False
     """Drive rollouts through the env-server worker pool (sized by `--pool.*`) instead of
     in-process — the path prime-rl trains through. Incompatible with `--rich`."""
+    push: bool = True
+    """Upload the finished run to the Prime Intellect platform (the private Evaluations
+    tab) at the end of the eval. On by default; disable with `--no-push`. Needs
+    `$PRIME_API_KEY` or `prime login`."""
     output_dir: Path | None = Field(
         None, validation_alias=AliasChoices("output_dir", "o")
     )
-    """Where to write the run (config.toml + results.jsonl). None = a fresh per-run dir
+    """Where to write the run (config.toml + traces.jsonl). None = a fresh per-run dir
     under `outputs/<env>--<model>--<harness>/<uuid>` (so runs never overwrite each other)."""
     resume: Path | None = Field(None, exclude=True)
     """Set by `--resume <dir>`: re-run only the rollouts a previous run left missing or

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/configs/replay.py

@@ -49,7 +49,7 @@ class ReplayConfig(BaseConfig):
     output_dir: Path | None = Field(
         None, validation_alias=AliasChoices("output_dir", "o")
     )
-    """Where to write the re-scored run (config.toml + results.jsonl). None = a fresh per-run
+    """Where to write the re-scored run (config.toml + traces.jsonl). None = a fresh per-run
     dir under `outputs/<taskset>--replay/<uuid>` (so a replay never overwrites the source run)."""
 
     @property

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/legacy.py

@@ -435,7 +435,7 @@ async def run_legacy_eval(config) -> list[Trace]:
 
     Loads the v0 env, runs `num_rollouts` per task with bounded concurrency, maps each v0
     `RolloutOutput` to a v1 `Trace` (`rollout_output_to_trace`), persists results as they
-    land (the same `results.jsonl` / `config.toml` a native run writes), and returns the
+    land (the same `traces.jsonl` / `config.toml` a native run writes), and returns the
     traces. The v0 env is run directly (`env.run_rollout`, no env server), so this needs no
     runtime / interception server. All v0 specifics live here; the CLI only branches on
     `config.is_legacy`."""

verifiers-0.1.15.dev437/verifiers/v1/push.py

@@ -0,0 +1,209 @@
+"""Push a finished eval run to the Prime Intellect platform (`uv run eval`, `--no-push` to skip).
+
+On by default. Converts each in-memory v1 `Trace` to the platform's (v0) eval-sample schema
+(`trace_to_sample`) and uploads the run over the `/evaluations/` API (create -> push samples ->
+finalize) — the same contract
+`prime eval push` uploads a saved run through, done inline at the end of a run rather than
+later from disk. Auth + base URL come from `$PRIME_API_KEY` / `~/.prime/config.json`
+(written by `prime login`), like the rest of the CLI.
+"""
+
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from verifiers.utils.client_utils import load_prime_config
+from verifiers.v1.configs.eval import EvalConfig
+from verifiers.v1.trace import Trace
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_API_URL = "https://api.primeintellect.ai"
+DEFAULT_FRONTEND_URL = "https://app.primeintellect.ai"
+
+
+@dataclass
+class PushState:
+    """Live status of the push, shared with the v1 `--rich` dashboard so it can show a status line
+    under the rollouts once the run finishes and the upload begins: dim while uploading, then the
+    viewer URL (green) or the error (red). `started` flips true when the upload begins (the caller
+    sets it), `done` when it returns; `url` is set on success and `error` on a skip/failure. No line
+    is shown until `started`. Populated by `push_traces` (pass the state in)."""
+
+    started: bool = False
+    done: bool = False
+    url: str | None = None
+    error: str | None = None
+
+
+def trace_to_sample(trace: Trace, rollout_number: int = 1) -> dict[str, Any]:
+    """One rollout -> the platform's sample dict (the "old" v0 eval-sample format).
+
+    The conversation is the unit — no prompt/completion split (meaningless mid-branch):
+    `completion` is the final branch's messages and `trajectory` carries one message list per
+    branch. `rollout_number` is this rollout's 1-based index within its task's group (callers that
+    don't group rollouts can leave it at the default)."""
+
+    def dump(messages):
+        return [m.model_dump(mode="json", exclude_none=True) for m in messages]
+
+    task = trace.task.model_dump(mode="json", exclude_none=True)
+    branches = trace.branches
+    sample = {
+        "sample_id": trace.id,
+        "example_id": trace.task.idx,
+        "rollout_number": rollout_number,
+        "task": task,
+        "prompt": [],
+        "completion": dump(branches[-1].messages) if branches else [],
+        "answer": task.get("answer"),
+        "reward": trace.reward,
+        "timing": trace.timing.model_dump(mode="json", exclude_none=True),
+        "is_completed": trace.is_completed,
+        "is_truncated": trace.is_truncated,
+        "metrics": trace.metrics,
+        "error": trace.error.model_dump(mode="json", exclude_none=True)
+        if trace.error
+        else None,
+        "stop_condition": trace.stop_condition,
+        "trajectory": [
+            {
+                "messages": dump(branch.messages),
+                "num_input_tokens": branch.num_input_tokens,
+                "num_output_tokens": branch.num_output_tokens,
+            }
+            for branch in branches
+        ],
+        "token_usage": trace.usage.model_dump(mode="json", exclude_none=True)
+        if trace.usage
+        else None,
+        "info": dict(trace.info) or None,
+    }
+    # Flatten each sub-reward onto the sample as a top-level key, the way v0's `state_to_output`
+    # does. Env metrics stay in the nested `metrics` field.
+    for name, value in trace.rewards.items():
+        sample.setdefault(name, value)
+    return sample
+
+
+def _creds() -> tuple[str | None, str, str, str | None]:
+    """(api_key, api_base, frontend_url, team_id) from env vars / `~/.prime/config.json`."""
+    cfg = load_prime_config()
+    api_key = os.getenv("PRIME_API_KEY") or cfg.get("api_key")
+    base = (
+        os.getenv("PRIME_API_BASE_URL")
+        or os.getenv("PRIME_BASE_URL")
+        or cfg.get("base_url")
+        or DEFAULT_API_URL
+    )
+    base = base.rstrip("/").removesuffix("/api/v1")
+    frontend = (
+        os.getenv("PRIME_FRONTEND_URL")
+        or cfg.get("frontend_url")
+        or DEFAULT_FRONTEND_URL
+    )
+    team_id = os.getenv("PRIME_TEAM_ID") or cfg.get("team_id")
+    return api_key, base, frontend, team_id
+
+
+def push_traces(
+    traces: list[Trace], config: EvalConfig, state: "PushState | None" = None
+) -> str | None:
+    """Upload a finished run to the platform; return the viewer URL (None if skipped/failed).
+
+    Resolves the env (get-or-create) by name so a local run uploads without a prior
+    `prime env push`, then create evaluation -> push samples -> finalize. When `state` is given
+    (the v1 `--rich` path), record the outcome on it (`url` on success, `error` on skip/failure,
+    `done` when finished) so the dashboard's status line resolves."""
+
+    def finish(url: str | None = None, error: str | None = None) -> str | None:
+        if state is not None:
+            state.url = url
+            state.error = error
+            state.done = True
+        return url
+
+    api_key, base, frontend, team_id = _creds()
+    if not api_key:
+        logger.warning(
+            "--push: no PRIME_API_KEY (set it or run `prime login`); skipping upload"
+        )
+        return finish(error="no PRIME_API_KEY (run `prime login`)")
+
+    def compute_metrics() -> dict[str, Any]:
+        """Run-level aggregates as v0's `GenerateMetadata`: `avg_reward` (mean over all traces),
+        `avg_metrics` (each sub-reward and env-metric averaged over the traces that recorded it),
+        and `avg_error` (errored fraction) — what the overview renders."""
+        sums: dict[str, float] = {}
+        counts: dict[str, int] = {}
+        for trace in traces:
+            for name, value in {**trace.rewards, **trace.metrics}.items():
+                sums[name] = sums.get(name, 0.0) + value
+                counts[name] = counts.get(name, 0) + 1
+        n = len(traces)
+        return {
+            "avg_reward": sum(t.reward for t in traces) / n if n else 0.0,
+            "avg_metrics": {name: sums[name] / counts[name] for name in sums},
+            "avg_error": sum(t.has_error for t in traces) / n if n else 0.0,
+        }
+
+    env_name = config.taskset.id or config.id
+    metrics = compute_metrics()
+    counts: dict[int, int] = {}
+    samples = []
+    for trace in traces:
+        counts[trace.task.idx] = counts.get(trace.task.idx, 0) + 1
+        samples.append(trace_to_sample(trace, counts[trace.task.idx]))
+
+    metadata = {
+        "framework": "verifiers",
+        "run_id": config.uuid,
+        "model": config.model,
+        "num_examples": len(counts),
+        "rollouts_per_example": config.num_rollouts,
+        **metrics,
+    }
+
+    team = {"team_id": team_id} if team_id else {}
+    api = f"{base}/api/v1"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    # The run is already done and its results saved; a network blip or platform error here must
+    # not crash the run (or, on the non-rich path, swallow the final per-trace output that prints
+    # after this) — log and skip the upload instead.
+    try:
+        with httpx.Client(headers=headers, timeout=300.0) as client:
+
+            def post(path: str, body: dict) -> dict:
+                resp = client.post(f"{api}{path}", json=body)
+                resp.raise_for_status()
+                return resp.json()
+
+            env_id = post("/environmentshub/resolve", {"name": env_name, **team})[
+                "data"
+            ]["id"]
+            eval_id = post(
+                "/evaluations/",
+                {
+                    "name": f"{env_name}--{config.model}--{config.uuid[:8]}",
+                    "environments": [{"id": env_id}],
+                    "model_name": config.model,
+                    "dataset": env_name,
+                    "framework": "verifiers",
+                    "metadata": metadata,
+                    "metrics": metrics,
+                    "tags": [],
+                    **team,
+                },
+            )["evaluation_id"]
+            post(f"/evaluations/{eval_id}/samples", {"samples": samples})
+            post(f"/evaluations/{eval_id}/finalize", {"metrics": metrics})
+    except Exception as e:
+        logger.warning("--push: upload failed (%s: %s); skipping", type(e).__name__, e)
+        return finish(error=f"{type(e).__name__}: {e}")
+
+    url = f"{frontend}/dashboard/evaluations/{eval_id}"
+    logger.info("--push: uploaded %d samples -> %s", len(samples), url)
+    return finish(url=url)

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/state.py

@@ -3,7 +3,7 @@
 `Trace.state` is a typed, mutable `State` that a rollout's tool servers (`@vf.tool`) and user
 simulator (`respond`) read+write as `self.state` (synced over the interception server per call), and
 that `@reward`/`@metric`/`finalize` read+write directly off the trace. Unlike `Trace.info` — the
-free-form artifact bag persisted to `results.jsonl` — `state` is transient runtime scratch (counters,
+free-form artifact bag persisted to `traces.jsonl` — `state` is transient runtime scratch (counters,
 game progress, an end-of-trajectory flag): never written to disk or sent over the wire.
 
 The base `State` is empty — the framework holds no opinion about its contents. Subclass it to declare

{verifiers-0.1.15.dev435 → verifiers-0.1.15.dev437}/verifiers/v1/trace.py

@@ -2,7 +2,7 @@
 
 A `Trace[TaskT]` carries the typed task plus everything produced during a
 rollout (conversation, per-turn responses, reward, metrics, timing, error). It is
-the canonical full data dump — written to disk (`results.jsonl`) and consumed by
+the canonical full data dump — written to disk (`traces.jsonl`) and consumed by
 the platform (visualization) and prime-rl (training). Environments subclass it to
 add typed scratch/result fields. The rollout mutates it directly; this replaces
 v1's 600-line `dict`-subclass `State` and its dual "contract version" machinery.
@@ -234,7 +234,7 @@ class Trace(StrictBaseModel, Generic[TaskT, StateT]):
     a reward nor a metric — anything an author wants to scrape off the live runtime and persist
     with the trace (captured logs, command output, container/runtime state, artifact paths).
     Populate it from the runtime in `finalize` (or a `@reward`/`@metric`) by assigning into the
-    dict (`trace.info["build_log"] = ...`); it round-trips through the wire to `results.jsonl`.
+    dict (`trace.info["build_log"] = ...`); it round-trips through the wire to `traces.jsonl`.
     Use `metrics` for numbers that aggregate, this for everything else. Values must be
     JSON-serializable — a non-serializable value fails the trace dump rather than being dropped."""
     state: StateT = Field(default_factory=State, exclude=True)
@@ -464,7 +464,7 @@ class Trace(StrictBaseModel, Generic[TaskT, StateT]):
         self.stop("error")
 
     def to_record(self) -> dict[str, Any]:
-        """A JSON-serializable record of this rollout for `results.jsonl` / W&B tables.
+        """A JSON-serializable record of this rollout for `traces.jsonl` / W&B tables.
 
         `model_dump(mode="json")` minus the per-node training tensors (`_NODE_DUMP_EXCLUDE`):
         those carry raw numpy bytes that JSON can't encode (the plain dump raises