fix: free runtime resources on exit/interrupt

[mikasenghaas]

Summary

A runtime provisions an external resource (a /tmp workspace, a docker container, a remote sandbox). stop() frees it on the normal path (it runs from the rollout's finally, covering success / error / cancellation), but a catchable exit (Ctrl-C / SIGTERM) can cancel that finally mid-teardown — and for an async teardown (a sandbox HTTP-delete, docker rm) the cancellation can cut it off, leaking the resource. Repeated leaks fill /tmp (No space left on device) or pile up sandboxes/containers.

General, backend-agnostic fix in Runtime:

• cleanup() — synchronous teardown, the source of truth (it must work from the atexit hook, where the event loop and its thread-pool are gone, so async teardown raises cannot schedule new futures).
• stop() — public async, the happy path. Defaults to running cleanup() off the event loop; prime overrides it for the async sandbox delete + client aclose.
• make_runtime registers each runtime in a WeakSet and arms a single sync atexit hook that calls cleanup() on anything still live. So a signal that cuts the finally short still frees the workspace / container / sandbox — reusing each backend's own cleanup, no per-backend signal code.

Per-backend cleanup() is plain blocking work: shutil.rmtree (subprocess), subprocess.run(["docker","rm","-f"]) (docker), tunnel stop + a sync SandboxClient(...).delete() (prime — so the sandbox, the costly resource, is deleted at exit too, not left to its TTL).

Also renames the v1- resource prefix to vf-.

SIGKILL is intentionally out of scope

SIGKILL/OOM can't be caught — no signal handler, atexit, or finally runs — so the dying process can't release anything external. Reclaiming those needs a mechanism outside the process (a startup reaper, a supervisor, or a server-side TTL). Prime sandboxes still self-terminate via their max_lifetime as the final net; a SIGKILLed subprocess/docker leaves its workspace/container, which is left out of scope here rather than carrying a PID-tagged reaper.

Verification

Ran gsm8k-v1 (real model arcee-ai/trinity-mini via Prime Inference) on all three runtimes, for the happy path and a mid-flight Ctrl-C, checking that no runtime resource is left behind before or after each run:

runtime	resource checked	happy path	Ctrl-C (interrupted mid-flight)
subprocess	/tmp/vf-* workdirs	0 → 2 rollouts, reward 1.0 → 0	4 workdirs in flight → 0
docker	vf-* containers	0 → container created & removed, reward 1.0 → 0	2 containers in flight → 0
prime	vf-program sandboxes	0 → sandbox created & deleted, reward 1.0 → 0	2 sandboxes in flight → 0

The prime Ctrl-C row is the important one: the two in-flight sandboxes were deleted on interrupt (via stop() / the sync cleanup() at atexit), not left to their max_lifetime.

Mechanism checks: confirmed the async teardown fails at interpreter shutdown (cannot schedule new futures) while the sync cleanup() succeeds (why the atexit path is sync), and that the prime sync SandboxClient(APIClient()).delete(...) path reaches the API.

---

Note

Medium Risk
Touches teardown for all runtimes including Prime API deletes and Docker container removal; behavior change on interrupt paths but idempotent and best-effort.

Overview
Adds a sync teardown path so runtimes still free workspaces, Docker containers, and Prime sandboxes when Ctrl-C/SIGTERM cancels the rollout finally before async stop() finishes.

The Runtime contract gains cleanup() as the idempotent, blocking teardown API; default stop() delegates to it via asyncio.to_thread. make_runtime registers each instance in a WeakSet and arms a one-time atexit hook that calls cleanup() on anything still live. Subprocess, Docker, and Prime each implement cleanup() (e.g. shutil.rmtree, sync docker rm, sync sandbox delete + tunnel stop); Prime keeps async stop() for the normal API delete path.

Also renames runtime resource prefixes from v1- to vf- (workdirs, containers, sandboxes, script cache paths).

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

Note

Free runtime resources on process exit via synchronous cleanup() and atexit registration

• Adds a synchronous cleanup() method to the Runtime base class and overrides it in DockerRuntime, PrimeRuntime, and SubprocessRuntime to tear down containers, sandboxes, and processes without requiring an event loop.
• Introduces a WeakSet-based registry in base.py that lazily registers an atexit hook; all runtimes created via make_runtime are registered automatically.
• The default async stop() now delegates to cleanup() via asyncio.to_thread, unifying teardown through the sync path.
• Renames resource prefixes from v1- to vf- across Docker containers, Prime sandboxes, subprocess workspaces, and script paths under /tmp.
• Behavioral Change: existing resources created with v1- prefixes will not be matched or cleaned up by the new code; script paths under /tmp also change, invalidating uv cache keys.

^{Macroscope summarized 44edc4b.}

[macroscopeapp]

Approvability

Verdict: Needs human review

This PR adds new runtime cleanup infrastructure via atexit hooks and converts async cleanup to synchronous cleanup across all runtime types. These are meaningful runtime behavior changes affecting shutdown/interrupt handling that warrant human review.

^{You can customize Macroscope's approvability policy. Learn more.}