fix(coding-agent): single-dump kernel snapshots

[snimu]

Saving kernel state — the namespace snapshot that lets a resumed session keep its variables — buffered the whole pickled namespace in memory up to three times over before writing it to disk: each variable was pickled into a dict of blobs, that dict was pickled again into a second in-memory buffer, and that buffer was copied once more for the file write. A snapshot runs shortly after every successful cell, so long sessions with sizeable variables repeatedly spike to roughly 4x the payload in transient RSS. This is the kernel-side memory spike tracked in ENG-5819 (kernel processes ballooning to 1.3-1.9GB and getting OOM-killed).

The fix deletes the in-memory aggregate stage: the dict of blobs now pickles directly into the staged temp file through a small size-capped writer (the same class replaces the old per-variable buffer). The on-disk format, the manifest, the max_bytes cap semantics, and the overflow fallback that keeps the largest prefix that fits are all unchanged; overflow retries rewind and rewrite the temp file instead of allocating fresh buffers. No host or protocol changes.

Measured on a 250MB namespace (25 x 10MB variables, fresh process per side, 3 snapshots, ru_maxrss):

	peak RSS	snapshot transient overhead	latency
before (74c8d39)	1242 MB	963 MB (~3.9x payload)	0.11-0.20 s
after	529 MB	253 MB (~1.0x payload)	0.03-0.14 s

The remaining ~1x overhead is the per-variable blob dict, which pickling the aggregate genuinely needs. The snapshot still runs synchronously on the kernel loop; moving it off-loop is out of scope here because that ordering is what keeps the namespace stable while it pickles.

Validation: prime-agent-runtime python -m unittest test.test_repl 95/95 with no test changes (the cap and overflow-fallback behaviors are already pinned there); coding-agent kernel suites (repl-kernel-state-roundtrip against the real runtime, execute/abort/shutdown/startup/protocol-corruption, npm run test:kernel) green; root npm run check green.

Linear: ENG-5819

---

Note

Medium Risk
Touches the kernel snapshot write path used after every successful cell; behavior is intended to be equivalent but mistakes could truncate or mis-record state under size caps.

Overview
Fixes ENG-5819 by changing how _snapshot_state writes the aggregate namespace payload so the kernel no longer holds multiple full-size serialized copies in RAM on every debounced snapshot.

The in-memory _SnapshotBuffer path is replaced with _CappedWriter, which enforces per-dump byte limits while streaming dill output into a sink (still BytesIO for per-variable blobs, the staged temp file for the full payload dict). Aggregate overflow handling keeps the same largest-prefix binary search and skip reasons, but retries seek/truncate/redump on that temp file instead of re-pickling into fresh buffers.

Snapshot caps, manifest fields, on-disk format, and host protocol are unchanged; this is a memory/latency optimization inside the REPL kernel.

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

Note

Stream kernel snapshot payload directly to temp file instead of memory

• Replaces the in-memory _SnapshotBuffer (BytesIO wrapper) in prime-agent-runtime/src/rlm/repl.py with _CappedWriter, a capped writer that streams writes to an arbitrary sink while enforcing a byte limit.
• _snapshot_state now serializes the payload directly into the staged temp file using _CappedWriter instead of calling serialize() to build a full in-memory copy first. This reduces kernel memory spikes during namespace snapshots.
• The prefix-truncation binary search rewrites candidate prefixes to the temp file via seek(0)/truncate(); bytes_written is sourced from the writer's running count rather than len(serialized).
• Behavioral Change: _SnapshotBuffer is removed; any code importing it directly will break. Per-variable serialization now uses io.BytesIO + _CappedWriter instead of _SnapshotBuffer.

^{Macroscope summarized bffb62d.}