#90 mid-run diagnosis: the KL climb is a codec-view artifact, the run is healthy, and the mismatch roadmap

1 · TLDR: the four questions, answered

1. Is the current run OK? Yes. Let it finish untouched. Every dense-view health signal is green at step 599/600: val MATH acc went 0.451 (step 0, base) → 0.661 (150) → 0.663 (300) and is holding; train score 0.35 → 0.73; grad norm is 1.3-2.0 and falling; the kl_loss climb is linear and decelerating (slope 0.0020/step over steps 60-150, 0.0015/step over 150-330). The climbing actor/kl_loss and actor/entropy live in the codec view (both nets measured through the 95% mask); they are not the collapse signature. The plan gate "kl_loss well under 0.2" is formally breached (0.50 @ 599) but that number was calibrated on 100-step history; every mechanism-level precursor of a real break is absent (section 4 checklist). Projected codec-view kl_loss at step 600 if the current slope holds: about 0.9.
2. Can the anchor do more, within the comm budget? Partly, but not by replaying harder: anchor replay measurably does not bend the KL curve (dKL over the 2 steps after each of the 16 fires: 0.0037 vs 0.0027 elsewhere, i.e. noise). The anchor bounds weight drift; the wedge is a sampler-vs-trainer view gap, not weight drift. The cheapest real lever is not on the slow→fast wire at all: the sampler's own token logprobs are already local to the fast circuit (zero bytes) and enable decoupled token-IS / rejection / calibration. The one genuinely new anchor lever this analysis proposes: the anchor is the natural calibrator; it already recomputes dense logprobs on replay batches, so shipping the fast circuit's codec-view logprobs to it (1 float/token, ~2.6 MB per replay) lets it fit a systematic-bias correction and broadcast back ~28 bytes. Sign-of-M remains available (193 MB vs 3.09 GB full M, 16x) but M is anchor-owned today and its absence on the fast side is not what causes the mismatch.
3. bypass_model / inference-engine probs / systematic bias / better selection? bypass_mode=true today would not diverge, it would silently stop learning: the mean per-token log-ratio between codec-view trainer and dense sampler is -14.4 nats, so ratios are ~6e-7; positive-advantage tokens get e^-14-scaled gradients and negative-advantage tokens get exactly zero through the clip. The viable form is the decoupled mode already in the codebase: token-IS on PowerSGD (clvaf683) cut kl_loss 64% (9.84 → 3.54 @200), prevented entropy collapse (1.78 vs 0.027) and kept +2.6 val points at 200; its cost is an agreement filter (mean IS weight ~0.2). Treating the mismatch as a systematic bias is the right next idea and is measurable for a few logging lines (section 6.3): if a fitted global/per-layer calibration absorbs most of the 14.4 nats, calibrated correction becomes feasible; if dispersion stays huge, only filtering works. "Send the most important activations" is the coherence trap: every importance/structure-adding lever measured in #89 paid for it in KL (rms_match +38x, FRLR +5-16x); random selection is the feature. We are not using arXiv 2603.19470 (ALP); it is an off-policy-correction paper whose zero-mean-noise theory independently predicts exactly our PowerSGD-collapses / PRF-benign split (section 6.5).
4. RL gradients are sparse-but-high, so is this theoretically fixable? True for the weight/update channel, and that channel is already solved (movement at collapse is 0.03-0.13% with cosine ~1.0; rank-1 RELEX + signed-EMA ride exactly this). The activation channel is different: hidden states are dense, and what breaks training is not lost magnitude but directional bias times coherence. Sparsity arguments do not transfer; unbiasedness arguments do. Fix = keep the random codec + police the policy accounting (IS/RS/calibration), not "send bigger coordinates".

2 · The run at a glance

3 · Reading the four worrying panels correctly

The four panels that triggered this analysis measure three different policies. Keeping them separate is the whole diagnosis:

3.1 The wedge is flat; the sharpening is what rises

rollout_corr/kl = training_log_ppl - rollout_log_ppl (per-token nats). The codec-view side (training_log_ppl, the wedge proper) has moved 14.46 → 14.39 (min, step 52) → 14.74: a ±0.1-nat band over 599 steps. The dense side (rollout_log_ppl) fell 0.84 → 0.09 because the policy is getting more confident on MATH: normal, wanted RL behavior. Of the +0.81-nat rise in the gap, +0.71 (87%) is the dense policy sharpening and only +0.10 (13%) is codec-side drift. Contrast PowerSGD (rose): its wedge itself explodes 4.4 → 29.5 nats while the policy sharpens into its own codec's preferences, and val crashes.

Note the level: the codec-view trainer assigns on average e^-14.5 ≈ 5e-7 probability to the tokens the dense sampler actually picked, which is below uniform (uniform over the 152k vocab = 11.93 nats). At 95% masking the codec view is not "the policy plus noise"; it is a different, nearly-random policy whose gradient is nonetheless useful in expectation because the mask is fresh, zero-mean and incoherent across steps. That is the entire PRF-vs-PowerSGD story in one number.

4 · Verdict: healthy, with named tripwires

4.1 Collapse-signature checklist (run 90 vs the PowerSGD break)

4.2 Tripwires for the remaining steps (observe only)

• kl_loss slope over any 30-step window > 0.004/step (2.7x current), or the curve turning convex;
• entropy leaving the structural band downward (< 7.75 and falling): the PowerSGD signature is sharpening-through-the-codec;
• rollout_corr/training_log_ppl > 15.0 (wedge growth, currently 14.6);
• ppo_kl > 1e-2 sustained (within-step identity break);
• val@450 < 0.63 (> 3 points off the 300-step value).

If a tripwire fires, the action is still not intervention mid-run; it is labelling the close-out verdict and the follow-up arm correctly.

5 · Question 2: the anchor, the wire, and what actually fits through it

5.1 What the anchor can and cannot fix

Measured on this run: the 16 anchor replay fires (every 20 ticks) produce no detectable bend in the codec-view KL (mean dKL over the 2 steps after a fire 0.0037 vs 0.0027 elsewhere). This confirms the #88 exoneration from the other side: the anchor's job is bounding weight-space drift (which it does; at these horizons total weight movement is fractions of a percent), while the kl_loss climb is the policy adapting to the mask distribution and sharpening, seen through the codec. More replay, smarter replay timing, or a stronger M transaction cannot remove a wedge that lives in the forward-pass view, not in the weights. Within the fixed cadence/delay 20/20 contract, the anchor is already doing its part.

5.2 The communication budget, itemized (this config, 659k tokens/step)

5.3 Why dense rollouts are the correct realistic design (not an artifact)

In the deployed two-circuit system the community GPUs do rollouts on full local replicas (a 1.5-2B policy fits on any of them; only weights need syncing, which rank-1 RELEX already carries), while training crosses the compressed pipeline. Sampling through the codec instead would make the mismatch zero by construction but would sample from the e^-14.5 near-random codec policy: garbage data, and our own #89 frame shows the codec view is not a usable generator. PP-decode across internet links is also latency-hopeless independent of compression. So the asymmetry this run trains under (dense sampler, compressed trainer) is the realistic one, the wedge is intrinsic to the design, and the correct place to handle it is the training-side objective. That is question 3.

6 · Question 3: inference-engine probs, systematic bias, and what to send

6.1 bypass_mode=true would be gradient starvation, not divergence

With bypass_mode=true, old_log_prob := vLLM logprobs (dense view) while new logprobs stay codec-view. The initial ratio is then r = exp(logp_codec - logp_dense) with mean log-ratio -14.4 nats → r ~ 6e-7 on typical tokens. Through the PPO-clip objective: for A>0 the unclipped branch is active and the gradient is scaled by r ≈ 0; for A<0 the min picks the constant clipped branch and the gradient is exactly zero. Net effect: learning silently stops, with the residual signal concentrated on the rare tokens where the codec view happens to agree with the sampler (the sampled-token chi-square estimate rollout_corr/chi2_token sits at -0.9 to -0.98 late in the run: essentially no such tokens are being sampled any more). The same holds for loss_type=reinforce with truncated IS weights (min(r, 2) ≈ 0). Do not use bypass_mode while the trainer forward is a 95% codec view. It is the right tool for the numeric dense-vs-dense mismatch it was built for (probs correlation ~0.97, not ~0).

6.2 The decoupled token-IS route is proven on our own data, and what it costs

clvaf683 ran the exact machinery this fork already has (rollout_is=token, threshold 2.0, decoupled mode) on top of the PowerSGD codec, whose wedge was 4-6 nats when correction started:

Mechanism: at multi-nat wedges token-IS does not "correct" the distribution in the textbook sense (the ESS is tiny); it acts as a soft filter that routes gradient through the tokens where the two views agree, killing the self-reinforcing bias loop. That is why it stops PowerSGD's collapse. Under PRF's 14.4-nat wedge the filter would be much more aggressive; since run 90 is healthy without it, switching it on now would mostly slow learning. The right use is as insurance on longer horizons or coherent codecs, in the step-size-preserving form: IcePop band + batch normalization (rollout_is=token, rollout_is_threshold="0.5_2.0", rollout_is_batch_normalize=true), which zeroes disagreement tokens and renormalizes the surviving weights to mean 1 instead of shrinking the whole step. All of it is config-only and zero wire bytes.

6.3 Treating the mismatch as a systematic bias: the decisive cheap measurement

Decompose the per-token cross-view gap d_t = logp_dense(a_t) - logp_codec(a_t) = b + eps_t, where b is a systematic, slowly-varying calibration term (mean shift and/or temperature of the codec logits) and eps_t is zero-mean per-token noise. We know E[d] ≈ 14.4 nats; nobody has measured the dispersion of eps after fitting b. That single number decides the road:

• If a global or per-boundary calibration (temperature + offset on the codec logits) absorbs most of the gap (residual std ≤ 1-2 nats), then "eliminate it as a systematic bias" works: apply the calibration inside the training objective (or anchor-broadcast it, 28 B) and calibrated IS / even calibrated bypass become numerically sane.
• If the dispersion stays huge (the mask damage is intrinsically per-token), calibration is a dead end and filtering (6.2) is the only policy-accounting tool; codec-side variance reduction is then the frontier (and #89 already mapped its walls).

Cost: ~6 lines in compute_offpolicy_metrics (log p10/p50/p90 quantiles and the post-fit residual std of d_t), zero GPU passes, zero wire. In the deployed two-circuit design the anchor is the natural place to fit b: it already recomputes dense logprobs on the replay batches; ship it the codec-view logprobs (2.6 MB per fire) and it returns the fit. The fit itself is closed-form (mean/temperature regression on logits it already has).

6.4 "Send the most important activation info" is the coherence trap

The intuition "we are losing info, send the important part" was tested to destruction in #89: every lever that added structure or importance to the selection paid for it in KL, because the failure mode is not lost magnitude, it is directional bias times cross-step coherence. rms_match rescale: entropy down but KL +38x. FRLR low-rank residual correction (rank 16/32/48 at the same 77-value budget): entropy down 2.4x but KL +5-16x, and slowing its Q refresh made KL sawtooth: the closer the codec tracks "important" directions, the more coherent its bias, the faster the reference-KL climbs. The two survivors of the whole search are exactly the two levers that preserve randomness: exact-k (fixes the keep count, keeps selection random; the codec this run validates) and antithetic draws (-7% KL, weak). Magnitude top-k is banned in the codec code on purpose. The realistic best-case for "smarter selection" at this budget is FRLR r48 with fast Q refresh, and it was goal-nearest but still KL-climbing when the #89 budget gate closed. Improving what we send is therefore a variance-reduction game with a measured ceiling, not the fix for the wedge.

6.5 arXiv 2603.19470 (ALP): are we already using it? No, and what to take from it

"Adaptive Layerwise Perturbation" (Amazon/UIUC, 2026) targets train-inference mismatch and staleness in LLM RL by adding learnable zero-mean Gaussian noise to every layer input during the update forward (sigma ~1e-4, learned; fresh per token per forward) and optimizing a single unified ratio pi_perturbed-train / pi_vLLM: their numerator is perturbed, their denominator is raw inference-engine logprobs. On Qwen2.5-Math-1.5B RLVR it beats GRPO/Bypass/MIS baselines by 1.5-4 points with visibly better stability.

• We do not implement ALP. No learnable noise scale, no unified ratio: our objective never sees the sampler's probs (both ratio sides are codec-view), which is why our ratio is 1 and theirs is not.
• But PRF is formally a member of their perturbation family (their footnote allows non-Gaussian zero-mean noise; inverted-dropout masking qualifies) at ~4 orders of magnitude larger amplitude, applied at 7 boundaries instead of all 28 layers, frozen per step instead of fresh per forward. Their Theorem 1 bounds the train-infer KL only when the noise scale covers the system noise and stays small; at our amplitude the bound is vacuous. So ALP-as-published does not absorb a 95% codec wedge, and their own Bypass baseline (= our 6.1) blew up at a mismatch 100x smaller than ours.
• Independent confirmation: their theory needs the perturbation to be zero-mean; that is precisely the property PowerSGD violates (coherent directional bias) and PRF satisfies. Their framework predicts our benign/collapse split without having seen it.
• Worth stealing, cheap: (i) tiny learnable Gaussian layer-input noise as a curvature smoother on top of a codec: near-zero cost, plausibly delays coherent-codec breaks (their early-layer ablation matches where our collapse-era spatial shift lives); (ii) their per-forward-fresh noise suggests a PRF knob (refresh the mask per pass instead of per step; seed-only, zero comm) - flagged with the caveat that it breaks our within-step bit-identity (ppo_kl would become nonzero) so it must be paired with 6.2-style correction.

7 · Question 4: "RL gradients are sparse but high, so this should be fixable"

Half-right, and the half matters:

• Weight/update channel: yes, and it is already exploited. RLVR moves the network astonishingly little (our own measurement: relative weight change 0.03-0.13% with cosine ~1.0 to the dense trajectory, even at codec-KL blow-up), and single-block RL can match full GRPO (LayerCompass, arXiv 2607.01232). This is why rank-1 RELEX carries the slow→fast sync at ~3 MB and why sign-compressed momentum (16x) is on the table. This channel is not the problem.
• Activation channel: sparsity does not transfer. Hidden states are dense and high-entropy; per-token top-77-by-magnitude is not "the gradient's sparsity", it is a deterministic, coherent selection, and 6.4 shows what coherence costs. The random mask works because gradients through it are unbiased in expectation (E[h~] = h), not because 77 values carry the information.
• The residual failure mode is not bandwidth. The wedge is a function-space gap created by nonlinearity (log-softmax of a masked forward is not the masked log-softmax; that Jensen gap IS the structural 14.5-nat / 7.8-entropy codec view). More clever bytes at the same budget can shrink variance (measured ceiling: -7% KL) but cannot remove the wedge; policy-accounting tools (6.2/6.3) are the ones that act on it directly.

8 · The fix, decided (v2 addendum, 2026-07-24)

Version 1 of this report ranked options. This addendum replaces the ranking with a decision, after (i) computing the feasibility numbers directly from the run's own logs, (ii) a verified literature sweep (section 9), and (iii) implementing the resulting kit on branch exp/mismatch-control-kit (local, CPU-tested).

8.1 What exactly is rising, and which piece fixes which curve

8.2 The kill table: corrections that are measurably impossible here

From the k3-kl estimator identity, E[ρ] = k3_kl - kl + 1 gives the exact untruncated mean token-IS weight between the codec-view trainer and the dense sampler, per step, from already-logged data:

Consequence: for the PRF codec at this compression, the entire policy-reaccounting family (bypass, TIS, MIS, IcePop, GSPO, calibrated IS) cannot fix the curves, because there is almost no per-token overlap left to reweight. The fix has to reduce the per-token view noise itself. (These tools remain valid and proven for the milder coherent-codec regime: clvaf683.)

8.3 The prescription

1. P0 (this run): change nothing. Finish to 600; judge on the section-4 checklist; the curves as they stand are codec-view projections of healthy learning.
2. P1 (control plane; permanent for all comm-eff runs): measure the true KL and bound it by construction.
   • Log-ratio distribution metrics every step (rollout_corr/logratio_p10|p50|p90|std, agree_frac_1nat): implemented on exp/mismatch-control-kit.
   • Dense-view probe every 25 steps: rerun the old-logprob + reference recomputes once with the codec disabled (no backward), logging probe/kl_dense, the gain probe/kl_gain = kl_loss/kl_dense, and the numeric vLLM-vs-trainer baseline. ~1-2% step-time overhead in the sim; in deployment this probe belongs to the anchor (it holds full weights and already receives the batch; 28 B comes back).
   • Adaptive kl_loss_coef: PI controller targeting probe/kl_dense ≤ 0.02 at horizon (Schulman-style adaptive beta, driven by the dense measurement, acting through the existing codec-view penalty). After this, real drift cannot run away no matter what the codec-view panel does; the codec-view panel is relabeled as G x dense-KL with G logged.
3. P2 (fix at the source; the next codec experiment): replace 5%-random-keep with unbiased low-bit dense quantization: the sr_quant codec. All 1536 dims cross the boundary at 1-2 bits with blockwise scales (absmax per 32 dims) and PRF-keyed stochastic rounding, forward and backward. Zero-mean like PRF (the property that makes it collapse-safe), but bounded one-step noise instead of x20-or-x0 heavy tails: noise energy ~7x signal at 1-bit/1.87x bytes, ~0.9x at 2-bit/3.1x bytes, and ~5x at EXACT byte parity (2-bit on a random 493-dim subset), vs 19x heavy-tailed for the incumbent. Predicted: wedge 14.5 → low single digits, codec entropy 7.8 → ≤3, gain G collapses, and if the wedge lands under ~3 nats the IS toolbox re-activates as a safety net. Mandatory control arm: deterministic round-to-nearest at the same grid (NVFP4 found RN safer in their setting; our coherence mechanism predicts RN is the dangerous one here; measure it).
   
   Status: implemented, CPU-verified, and adversarially reviewed. Local branch exp/mismatch-control-kit (commits 001769fe metrics, d891b533 codec, 20f5b82b launcher plumbing, 9b4e87f9 review fix; ~1590 lines over 17 files; 136 tests pass including 38 new sr_quant tests covering unbiasedness, PRF determinism, cross-pass ratio identity, backward quantization, block scales, rn mode, and path confinement; a pre-GPU boot gate validates the knobs). A three-lens adversarial review panel (quantizer math, PRF/identity, config wiring) confirmed the codec clean; its one confirmed finding (the new quantile metric would crash on batches above torch.quantile's 2^24-element cap, latent for committed configs but zero-headroom for long-context arms) was reproduced on torch 2.12 and fixed in 9b4e87f9. Launch block for the arm:

   COMM_EFF_ENABLED=true COMM_EFF_COMPRESSION_TYPE=sr_quant \
   COMM_EFF_QUANT_BITS=1 COMM_EFF_QUANT_BLOCK_SIZE=32 COMM_EFF_QUANT_ROUNDING=sr \
   COMM_EFF_MASK_RECOMPUTE=true COMM_EFF_MASK_REFERENCE=true \
   COMM_EFF_MASK_PP_SIZE=8 COMM_EFF_ANCHOR_OWNS_Q=false \
   COMM_EFF_POWERSGD_FAST_Q_BOOTSTRAP=false \
   bash examples/grpo_trainer/run_qwen25_math_1p5b_rank1_relex_fsdp.sh

4. P2b (exploratory, one arm): codec-view consistency (CVC). Add λ x CE_codec = -λ E[log π_codec(a)] on sampled tokens: this term literally IS the wedge, differentiable through the existing train forward, zero extra passes, zero wire. λ ≈ 0.003 with warmup, kill-guard on dense-side metrics (the codec view is below-uniform, so the early CE gradient points toward uniformizing it: watch rollout_ppl/val).
5. P3 (insurance, coherent codecs only): token-IS as proven in clvaf683, unchanged.
6. Standing no-gos (measured): bypass_mode under a codec view; token-IS/IcePop directly on PRF p=0.95; magnitude top-k selection; cross-step error feedback on activations (refuted conceptually and empirically, section 9); sampling through the codec; spending wire budget on shipping M.

9 · Literature check (verified sources)

9.1 Train-inference mismatch fixes in LLM RL: what survives at our gap

Every method below was validated at engine-level mismatch of 1e-4 to 1e-2 nats/token. Our regimes: (i) coherent codec 4-6 nats (PowerSGD), (ii) random codec ~14.4 nats bimodal (PRF p=0.95). The field's toolbox splits into three tiers; at regime (ii) only tier 3 survives.

Two further load-bearing notes from the sweep: Dropout-GRPO (2606.10184) formalizes the correct frame for our codec ("a masked network is a sampled policy, not a biased estimate of the dense one"), and Rethinking KL Regularization (2510.01555) shows the k3/low_var_kl loss estimator is itself a biased first-order approximation at large ratios: one more reason the codec-view kl_loss panel must be read through the P1 dense probe rather than at face value.

9.2 Activation compression for pipeline-parallel training

Verified anchors behind P2: SWARM (2301.11913) and Petals (2209.01188) ship 8-bit blockwise boundary activations across the internet losslessly (nothing published below 8 bits at the boundary; sr_quant probes that gap). ActNN (2104.14129) and GACT (2206.11357): unbiased stochastic ~2-bit activation quantization yields convergent, variance-characterized gradients (backward-storage setting). QSGD (1610.02132) supplies the unbiased quantizer and its variance bound, and its bucketing is why sr_quant uses blockwise scales; Gupta et al. 2015 (1502.02551) and Croci et al. 2022 are the canonical stochastic-rounding citations (E[q]=h, per-element variance ≤ Δ²/4). AQ-SGD (2206.01299) compresses activation deltas but requires per-sample recurrence across epochs, which fresh RL rollouts never provide (its DirectQ baseline: direct 2-3-bit boundary quantization degrades in SFT, the closest published control to our arm); Clapping (2509.19029) exists precisely because of that limitation. Rudakov et al. (2401.07788): boundary sparsification floor at ~10% TopK, and error feedback on activations does not help: the incumbent PRF 5% random-keep sits below that floor with the worst variance profile of the family. QuEST (2502.05003) trains transformers with 1-bit activations via Hadamard rotation (the extension knob if sr_quant wins); NVFP4 (2509.25149) is the counterpoint mandating the SR-vs-RN ablation. No published work combines low-bit boundary compression with RL, and none applies policy-ratio corrections to codec-induced mismatch: both points are unoccupied territory.

10 · Capability preserved: dense vs PRF-compressed (in-domain + OOD)

A byte-matched dense control (90-dense-600: identical config, only comm_eff.enabled=false) was trained 600 steps on MATH alongside the compressed run. Its in-domain val tracked the compressed run throughout (MATH-test acc @0/150/300/450/600 = 0.449 / 0.659 / 0.665 / 0.687 / 0.677, vs compressed 0.451 / 0.661 / 0.663 / 0.673 / 0.661). Both step-600 checkpoints were then pulled from R2 and evaluated through the same harness — greedy mean@1 for the large sets, avg@8 (temp 0.7) for the competition sets.

Compressed is higher on 6/10 benchmarks, dense on 4/10 — consistent with run-to-run noise, not a compression penalty. Checkpoints in R2 under .../90-prf-exactk-600/prf-exactk/ and .../90-dense-600/dense/; figure + numbers in artifacts/90-prf-exactk-600-mismatch-diagnosis/compare_dense_vs_prf_step600.{png,csv}. Dense run: WandB 90-dense-600/a134dxxx.

11 · Provenance

• Live run: shamanework-pl/90-prf-exactk-600/woqs8zra, full scan_history() pull 2026-07-24, 599 training rows; box checked read-only over SSH at step 337 (train.log tail, GPU/disk, tmux). No write of any kind was performed on the box or the run.
• Comparators: quick-test/tb4m0k23 (PowerSGD r77 W2, 200 steps) and quick-test/clvaf683 (PowerSGD + decoupled token-IS 2.0, 200 steps), full history pulls; #89 reference frame from runs/89-prf-codec-autoresearch-benign-kl verdict (dense 0.181/0.0033, dropout 0.137/0.124 @40).
• Code read at origin/autonomous-harness-v1 (2ac5740d): verl/workers/comm_eff/activation_mask.py (PRF, exact-k order statistic, top-k forbidden), verl/trainer/ppo/rollout_corr_helper.py + ray_trainer.py (bypass vs decoupled modes, metric definitions), launcher chain run_prf_exactk_600.sh → run_qwen25_math_1p5b_rank1_relex_fsdp.sh → vast_comm_eff_engine_grpo.sh (rollout correction strictly off; calculate_log_probs=true).
• Paper: arXiv 2603.19470 v3, read in full (19 pp).
• Step-0 val (0.4509) read from on-box train.log line 1076; it never reached WandB (known step-0/final-step logging race).
• Figures: generated from the CSV pulls kept in the repo-local (gitignored) artifacts/90-prf-exactk-600-mismatch-diagnosis/; regenerate with the session scripts (pull_wandb.py + gen_report.py).
• v2 addendum: data refreshed through step 599; the E[ρ] feasibility series computed from the k3-kl estimator identity on logged metrics; every literature claim in section 9 verified source-by-source (arXiv abstracts / PDFs fetched); the P1 instrumentation and P2 sr_quant codec implemented and CPU-tested on local branch exp/mismatch-control-kit (not pushed; the follow-up issues carry arms and gates).