docker: queue encoded column rows and cut the per-batch work of the equity proof - #652

Report wrapper: queue the encoded trade rows and cut the per-batch work of the equity proof

No report byte changes. Two pieces of per-row Python work in the report wrapper (docker/run_json.py) are removed; every output (stdout, sink bytes, receipt, error text and order) is identical to the previous commit.

What changes

• Trade spool. Every ordinary trade row cost two logical writes to its column (the separator and the row) and one dispatch through the generic JSON streamer. The row is now encoded once with the same json.dumps configuration the scalar fast path used and queued, with its separator, in the artifact file. The queue is joined inside the existing bounds (512 records, 256 KiB; no new bound, no new constant) and drained before any write, flush, read, rewind or close of that file, and after the checked reader close of a fused verification. Logical writes per trade column fall from 2T-1 to ceil(T/512); generic streamer dispatches per trade fall to zero. The physical byte stream, the aligned windows and the sync count are unchanged.
• Equity proof. The permitted repeat of the original run pattern is derived once with the pattern instead of by parsing the pattern text for every batch, and the first and last endpoints of the curve are decoded on demand (two for the whole curve) instead of building two dictionaries for every batch. Equity rows are interleaved with trades, so the old cost was paid about once per twelve rows. Every per-row numeric proof stays: the timestamp range, the finite check, and the canonical repr comparison of every number. The repeat bound still belongs to the run pattern alone.
• Not changed: window sizes, sync policy, the final-artifact copy, pf_sink.py, the native engine.

Failure behaviour

A write can now be attempted later than the row that queued it. The published refusal is the same: a failed physical write clears the queue first, so the same text is never retried; a failure while draining the tail becomes the same typed report_sink_failed / scratch_io refusal with the OSError as its cause, remembered and raised at the same point relative to the format, trailer, receipt, fd-identity, trade, summary, metric and equity refusals. Fault rows cover a write, flush, close and short write failing at the first, a middle and the last row or batch, each against every competing refusal.

Memory

The queue is one bounded list per artifact file, bounded by the existing 512-record and 256 KiB constants (a single oversized row is written alone). Nothing grows with the number of trades or bars.

Tests

docker/run_json_spool_work_test.py (166 cases) with its reference module docker/run_json_spool_reference.py (not collected by the harness glob; verbatim copies of the previous functions). Counters come from the interpreter (sys.setprofile on the real frames and wrapped pattern objects), each with a positive control on the reference and a mutation row that puts the removed work back. Byte identity of complete reports is checked over the existing families plus the finite float shapes and the flush boundary at 1, 511, 512, 513, 1024 and 4097 trades.

On the previous tree plus only these two files, 19 cases fail, as designed: 18 of them on the named work counter (SPOOL_ASCII_WRITES, SPOOL_STREAM_CALLS, EQUITY_BOUND_WORK). The 19th, test_equity_endpoint_dictionaries_belong_only_to_curve_endpoints, is red for the right work (the previous code builds eager endpoint dictionaries, which the counter records as eager rather than as endpoint dictionaries) but fails at a plain assertion on the counter value before the named check runs; the same counter's detection power is shown by the control inside that row and by two mutation rows. A follow-up reorders the assertion.

Notes for the record

• Because trade rows now reach their column through the queue, the existing mid-write failure test in run_json_bounded_transport_test.py (it patches _BoundedJSONFile.write) no longer exercises the trade spool: the first file it pushes past one window is now the final artifact. Every assertion in it still holds; the trade-spool write failure path is covered by the new file. A follow-up also patches write_ascii in that test.
• The strings the new tests put into entry_id, exit_id and exit_comment do not reach the changed encoder: those are trade fields the report drops, and the only string in the trade JSON is side. They test the report path as a whole, not the encoder's escaping; the encoder is covered by the finite-float and byte-identity rows.
• close() of the artifact file now closes the underlying file even when closing its buffer raises (before, the file close was skipped in that case). Benign; outside the queue itself.
• Doc pins into docker/run_json.py are repinned (digits only, 11 anchors, two pages).

🤖 Generated with Claude Code