[kcoopermiller]

Replaces monitors/prime.py'sTrainRun with pr.init(kind="train", ...).

What moved where

was in prime-rl	now
TrainRun.create / $RUN_ID attach	pr.init(kind="train", model=, environments=, training=pr.TrainingSpec(...), config=, ...) / pr.init(kind="train", id=$RUN_ID)
TrainRun.log_metrics (fire-and-forget task per POST)	run.log_metrics(values, step=) — a queue put; the SDK's uploader owns retries, Retry-After, backpressure
episodes_to_parquet_bytes + SAMPLE_SCHEMA + presign→PUT→confirm	prime_runs.projection + the SDK's training samples sink (same schema, same flow)
the step % 10 cadence in log_episodes	the sink (step_interval=10), keyed on each episode's run.work.step — the TrainRunInfo the dispatcher stamps
finalize → POST /finalize, fallback set_status	run.finish() — drain, then an idempotent finalize; 409 on the failure path is treated as already-closed
atexit _mark_failed	the SDK's atexit hook reports crashed (with a message); an attached run's failure marking stays with the launcher, as before

The kind == "train" and subset == "effective" cohort filter stays here. The monitor keeps sanitize() so dropped non-finite metric paths are still named in the log (the SDK would drop them silently). $PRIME_API_BASE still works — it historically points at …/api/v1/rft, so the monitor strips what the SDK re-adds.

Decisions

• Step keying. The samples sink keys each episode by the step it was dispatched at (run.work.step), not the batch step; the platform keeps one Parquet object per upload and the viewer unions every object under a step, so an off-policy episode landing in a later batch adds an object rather than replacing one, and each object numbers its sample_ids in its own range (SDK side, aba26790). "Step N" in the sample viewer therefore means dispatched at N, while the metrics at N describe the batch trained at N.
• Run identity. The orchestrator keeps the launcher's PRL_RUN_ID (or a local uuid) as the run identity for episodes, W&B and sandbox labels, exactly as on main. The SDK keys every uploaded record to the platform run (run.id / run.type on the uploaded copy, work kept), so Prime Traces documents carry the id the dashboard shows without the orchestrator learning it.

Dependency

prime-runs[train]>=0.1.1 from PyPI (0.1.1, PrimeIntellect-ai/prime#896); the lock carries prime-runs 0.1.1 + prime-traces 0.0.3 from the registry. The monitor's own unit tests run in CI; there is no GPU-free end-to-end path for the training seam, so the RFT contract was verified by reading the platform's /api/v1/rft/* and /api/internal/rft/* routes against the SDK's calls.

Hosted managed runs

Since PrimeIntellect-ai/platform#4885, hosted managed runs start the orchestrator with --monitors.prime.name, RUN_ID, a per-run token in PRIME_API_KEY and PRIME_API_BASE=<platform>/api/internal/rft. prime-runs 0.1.1 (PrimeIntellect-ai/prime#895) addresses that internal router and sends the run's token in x-api-key, the header it authenticates on; 0.1.0 only spoke /api/v1 with a Bearer header and would have left those runs silently unmonitored. This monitor's _base_url() passes $PRIME_API_BASE minus the trailing /rft, which 0.1.1 accepts, so the floor bump is the whole change. External runs (prime-rl launched outside the platform) were never affected.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Fk5fBAAaTiPfJ5UpNyqxXR

---

Note

Medium Risk
Changes how training runs register and upload to the Prime platform (including hosted $RUN_ID / internal RFT paths); misconfiguration now fails launch instead of silently skipping monitoring, but orchestrator run identity for W&B stays unchanged.

Overview
Replaces the in-repo TrainRun HTTP/Parquet implementation in PrimeMonitor with prime-runs[train]>=0.1.1, so run registration (or $RUN_ID attach), metrics streaming, episode sample uploads, finalize, and crash reporting are owned by the SDK uploader instead of custom httpx + fire-and-forget tasks.

The monitor layer is now a thin adapter: pr.init(kind="train", …) on startup, run.log_metrics / run.log_episodes via asyncio.to_thread, and run.finish() with a 60s drain timeout. Local behavior kept where it matters: non-finite metrics are still sanitized with named warnings, only train / effective episodes are forwarded, and $PRIME_API_BASE is normalized for the SDK. Episode every-10th-step upload cadence moves into the SDK sink (keyed on dispatch step on run.work).

Docs in training.md describe the SDK, team allowlisting, PRIME_RUNS_MODE=disabled, and RUN_ID attach. Lock/pyproject add prime-runs and transitive prime-traces, with fast-track resolver entries.

^{Reviewed by Cursor Bugbot for commit aed9bbf. Bugbot is set up for automated code reviews on this repo. Configure here.}

[cursor]

Stale Bugbot comment from a previous run.

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

Want reviews to match your repository better? Bugbot Learning can learn team-specific rules from PR activity. A team admin can enable Learning in the Cursor dashboard.

^{Reviewed by Cursor Bugbot for commit 163cd60. Configure here.}