NeCast release files

.gitattributes

@@ -0,0 +1,91 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+splits/cohort/snapshot.json filter=lfs diff=lfs merge=lfs -text
+splits/cohort/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+splits/cohort/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level04/snapshot.json filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level04/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level04/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level04/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level08/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level08/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level08/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level08/snapshot.json filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level16/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level16/snapshot.json filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level16/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level16/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level01/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level01/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level01/snapshot.json filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level01/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level02/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level02/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level02/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+additional/sample_size_levels/level02/snapshot.json filter=lfs diff=lfs merge=lfs -text
+features/level32/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+features/level32/snapshot.json filter=lfs diff=lfs merge=lfs -text
+features/level32/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+features/level32/sample_metadata.jsonl filter=lfs diff=lfs merge=lfs -text
+features/registry/sample_identities.jsonl filter=lfs diff=lfs merge=lfs -text
+features/registry/architecture_split.jsonl filter=lfs diff=lfs merge=lfs -text
+features/registry/snapshot.json filter=lfs diff=lfs merge=lfs -text
+features/registry/raw_index.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,253 @@
+---
+license: cc-by-4.0
+pretty_name: NeCast simulations
+tags:
+- population-genetics
+- demographic-inference
+- effective-population-size
+- coalescent
+- msprime
+- simulation
+size_categories:
+- 100K<n<1M
+configs:
+- config_name: index
+  data_files: index/windows.parquet
+  default: true
+---
+
+# NeCast simulations
+
+Simulated genotype windows used to train and test NeCast, a neural network that estimates the
+size history of a population from 32 diploid genomes together with recombination and mutation
+maps. There are 109,248 windows. Each is 30 Mb of sequence sampled from 64 diploid individuals,
+with sequencing-like errors already applied, and each comes with its true size history. The
+files the network was trained on are included, as are the code and configuration that made the
+windows.
+
+![What the corpus covers](https://huggingface.co/datasets/Larrivhan/NeCast-simulations/resolve/main/figures/simulations_overview.png)
+
+**What the corpus covers.** **a**, Eight training windows drawn at random from each of the
+twelve families of size history, with the number of windows in each family. Each line is a
+window's 64 interval labels, drawn through the interval centres. **b**, Windows by the type of
+map stored with them. Every window carries sequencing-like errors except those with constant maps
+at the baseline rates. **c**, Variant sites per window, false sites included.
+
+## Contents
+
+| path | what it holds | size |
+|---|---|---|
+| `windows/000/` to `windows/027/` | the 109,248 windows, four per `.npz` file, with per-window metadata in the `.jsonl.gz` file of the same name | 567 GB |
+| `windows/receipts.jsonl.gz` | the receipt written when each file was generated, with its SHA-256 | small |
+| `index/windows.parquet` | one row per window: where it is stored, its split, how it was simulated | 0.05 GB |
+| `index/histories.parquet` | the epochs of every simulated history, by window | 0.93 GB |
+| `splits/` | the train / development / reserved split, and the windows used to train, validate and test the final network | 0.2 GB |
+| `features/` | what the final network reads, for the 104,996 train and development windows | 15.7 GB |
+| `additional/` | the same inputs for 1, 2, 4, 8 and 16 individuals, and a variant of the PSMC+ posterior | 63.1 GB |
+| `generator/` | the simulator code, the generation plan and the map scripts | small |
+| `tools/necast_windows.py` | a reader that needs only numpy | small |
+| `logs/` | build logs of the feature files | small |
+| `figures/` | the figures on this card | small |
+| `SHA256SUMS` | a checksum for every file except this card | small |
+
+The windows are grouped by generation chunk: `windows/NNN/` holds chunks `NNN000` to `NNN999`.
+Window `sim_XXXXXXXX` is member `XXXXXXXX mod 4` of file `fragment_{XXXXXXXX div 4}`. The run
+planned 110,000 windows in 27,500 chunks of four; 188 chunks were not generated, so window
+numbers have gaps. The index lists every window that exists.
+
+## How the windows were simulated
+
+- **Sequence and sample.** 30 Mb, 64 diploid individuals (128 haplotypes). msprime 1.4.2 with
+  the default coalescent with recombination (the full ancestral recombination graph), a binary
+  mutation model, the window's true recombination and mutation maps, and no gene conversion.
+- **Size histories.** Twelve families, named in `generator_recipe`: constant (`constant`),
+  exponential (`exponential`), one size change (`size_event`), several changes (`multi_event`),
+  bottleneck (`bottleneck`), event on a trend (`event_on_background`), random walk
+  (`spectral_walk`), sawtooth (`sawtooth`), zigzag-like (`literature_sawtooth`), founder chain
+  (`ooa_chain`), perturbed published human histories (`empirical_human_ne_template`; 191 curves
+  inferred by SMC++, phlash, MSMC2 and MSMC-IM), and the 18 single-population models of the
+  stdpopsim catalogue (`stdpopsim_single_pop`). Sizes stay between 100 and 1,000,000. The
+  realised parameters of every history are in the metadata.
+- **Maps** (`map_type`). A constant map at the baseline rates (`constant_clean`), constant
+  rates drawn at random (`constant_random_global`), synthetic heterogeneous maps
+  (`synthetic_heterogeneous`), or 30 Mb slices of the deCODE 2019 recombination map and the
+  Roulette mutation map taken from the same chromosomal interval (`empirical_slice`).
+- **Errors** (`noise_profile`). `mild_noise` windows have genotype errors, missing calls, false
+  variant sites and phase switches within individuals, at rates drawn per window and recorded
+  in the metadata (`noise_*` fields). `clean` windows, which are the `constant_clean` ones,
+  have none.
+- **Maps stored with a window** are the maps a method is given. Constant maps are stored
+  exactly. Synthetic and empirical maps are stored as the true map seen through noise: a
+  log-normal factor with mean one on short cells (`observed_cell_bp`), smaller for the mutation
+  map, and for synthetic maps some hotspots left out. The noise size is in the metadata
+  (`observed_noise_sigma`, and `rec_slice_*` and `mut_slice_*` for empirical slices). The true
+  maps are not stored.
+- **Labels.** `target_log10_ne` gives, for each of 64 time intervals spaced evenly in log time
+  between 50 and 500,000 generations ago, the average of log10 Ne over the interval (averaged in
+  log time) of the simulated history. The file also stores the true number of pairwise
+  coalescences and the total branch length in each interval.
+
+## Splits and the windows used by the final network
+
+Windows were assigned by a hash of their identifier: 100,000 train, 5,000 development and
+4,248 reserved. Four train windows have no PSMC+ output and belong to no split (`split = none`
+in the index), leaving 99,996 train windows.
+
+The final NeCast network was fitted on 89,996 train windows. Another 500 train windows picked
+the training epoch (`stage = validation`), and 500 development windows were the test set
+(`stage = test`); both sets of 500 sit at evenly spaced quantiles of the number of variant sites.
+`splits/stages.json` lists them by sample ID and by feature row.
+
+The 4,248 reserved windows were never used to train, select or score a network. Their PSMC+
+output was computed (it is in `features/psmcplus_store/`), but they were left out of every other
+feature file. Now that they are public, they no longer serve as an untouched test set.
+
+## Reading a window
+
+![One window](https://huggingface.co/datasets/Larrivhan/NeCast-simulations/resolve/main/figures/simulations_window.png)
+
+**One window, `sim_00000016`**: a perturbed published human history, slices of the deCODE and
+Roulette maps, and errors. **a**, Diploid genotypes of the 64 individuals at the 133 variant
+sites between 15.00 and 15.10 Mb: 0 pale grey, 1 light purple, 2 purple; missing calls are empty cells.
+**b**, The recombination and mutation maps stored with the window, averaged in 300-kb bins.
+**c**, The simulated history (grey) and its 64 interval labels (black), which are the
+network's targets.
+
+```python
+from huggingface_hub import hf_hub_download
+import sys
+
+path = hf_hub_download("Larrivhan/NeCast-simulations", "windows/000/fragment_00000000.npz", repo_type="dataset")
+hf_hub_download("Larrivhan/NeCast-simulations", "windows/000/fragment_00000000.jsonl.gz", repo_type="dataset")
+reader = hf_hub_download("Larrivhan/NeCast-simulations", "tools/necast_windows.py", repo_type="dataset")
+sys.path.insert(0, reader.rsplit("/", 1)[0])
+from necast_windows import Fragment, diploid_genotypes, TIME_EDGES
+
+frag = Fragment(path)
+w = frag.window(0)
+w["genotypes"].shape       # (n_sites, 128): 0/1, haplotypes 2i and 2i+1 are individual i
+w["missing"].sum()         # missing calls (their genotype bit is 0)
+g = diploid_genotypes(w)   # (n_sites, 64): 0, 1, 2, or -1 where a call is missing
+w["recombination_map"]     # breakpoints (bp) and rates per bp per generation
+w["target_log10_ne"]       # 64 labels on the intervals TIME_EDGES
+w["metadata"]["generator_recipe"]
+```
+
+The index is a parquet table, so `pandas.read_parquet("index/windows.parquet")` or the
+`datasets` library will load it. Filter it to pick windows, then read only the files you need.
+
+## File format
+
+Each `fragment_XXXXXXXX.npz` holds four windows; ragged arrays are concatenated, and an
+`*_offsets` array of length 5 marks where each window starts.
+
+| array | type and shape | meaning |
+|---|---|---|
+| `sample_id` | str (4) | window identifiers |
+| `variant_positions_bp`, `variant_offsets` | uint32, int64 | site positions; window k is `[off[k], off[k+1])` |
+| `genotype_packed` | uint8 (sites, 16) | 128 haplotypes, 8 per byte; haplotype h is bit `h % 8` of byte `h // 8` (`numpy.unpackbits(..., bitorder="little")`) |
+| `missing_flat_idx`, `missing_offsets` | uint32, int64 | missing calls as row-major indices into the window's (sites, 128) matrix; the genotype bit of a missing call is 0 |
+| `obs_rec_pos`, `obs_rec_rate`, `obs_rec_offsets` | float64, float32, int64 | recombination map: breakpoints in bp and the rate (per bp per generation) between them; window k has one rate fewer than breakpoints, so rates for window k start at `sum(len_j - 1 for j < k)` |
+| `obs_mut_pos`, `obs_mut_rate`, `obs_mut_offsets` | the same | mutation map |
+| `target_log10_ne` | float32 (4, 64) | labels |
+| `pair_coalescences_per_bin`, `branch_length_per_bin` | float32 (4, 64) | true pairwise coalescences and branch length per interval |
+| `pair_coalescences_outside` | float64 (4, 2) | pairwise coalescences before the first and after the last interval |
+| `sequence_length`, `n_haplotypes`, `packed_hap_bytes` | int | 30,000,000; 128; 16 |
+| `source_id`, `demography_type_id`, `generator_recipe_id` | int16 (4) | codes; the names are in the metadata |
+| `generator_schema_version`, `missing_storage` | | format version (1) and the missing-call encoding |
+
+Variant sites include the false sites added as errors. Positions are sorted; a few windows have
+two sites at the same position.
+
+The `.jsonl.gz` file has one JSON object per window with every parameter of its history, maps
+and errors. The index carries the same fields, flattened: nested objects become `noise_*`,
+`rec_slice_*`, `mut_slice_*` and similar columns, and short lists are stored as JSON text. The
+epochs of each history (`demography_breaks` in generations ago, `demography_values` and
+`demography_growth_rates`, as passed to msprime) are in `index/histories.parquet` as numeric
+lists, one row per window.
+
+**Inputs and labels.** A method under test should read only the genotypes, the site positions,
+the stored maps, the sequence length and the sample size. Every other field describes how the
+window was made (the history, the errors, the map type, the labels) and is there for selecting
+windows and for scoring.
+
+## Feature files (`features/`)
+
+All feature files cover the 104,996 train and development windows in one order: feature row r
+is window `splits/stages.json["feature_sample_ids"][r]`, and the index gives it as
+`feature_row`. NeCast reads 32 of the 64 individuals in a window; which 32 is fixed per window by
+a seeded permutation and stored in `features/level32/unphased_evidence_cache.npz` as
+`ladder_columns`.
+
+- `registry/` locates every train and development window in the fragment files
+  (`raw_index.jsonl`), with a byte-exact read-back check for each one.
+- `level32/unphased_evidence_cache.npz` holds summary statistics of the 32 individuals:
+  the folded site frequency spectrum, projected to 32 haplotypes to absorb missing calls
+  (`folded_sfs_counts`); linkage disequilibrium between sites 1 to 64 sites apart, by genetic
+  distance (`ld_features`, `ld_pair_counts`, with `ld_bin_edges_morgan` and `ld_lags`);
+  lengths of identity-by-state tracts between pairs of individuals in 7 kinds and
+  powers-of-two length classes (`ibs_counts`, `ibs_bin_edges_bp`); a Watterson estimate of the
+  size level (`nw_log10`), which anchors the network's output; per-window context values
+  (`context`); and the labels (`targets`). `features` and `coordinates` hold statistics over
+  32-kb sub-windows that the final network does not read. The network's site encoder reads the
+  genotypes of the 32 individuals straight from the window files, found through `registry/`.
+- `psmcplus_posterior/level32.npz` holds PSMC+ posteriors for the same 32 individuals,
+  decoded with the window's maps on the 64 intervals. The array is named `sidecar`
+  (104,996 × 256): columns 0–63 are the mean over individuals of the posterior share of the
+  window in each interval with a flat prior, 64–127 their standard deviation, and 128–255 the
+  same after one refit of the prior. `sidecar_present` marks rows with a value.
+- `psmcplus_store/shards/` is the PSMC+ output these posteriors were cut from: every window
+  (reserved ones included), four random sets of individuals, and sample sizes of 1, 2, 4, 8, 16
+  and 32. Each shard has `sample_id`, `features` (rows, 4 sets, 6 sizes, 256), `flags` (the
+  number of individuals scored in each pass), `theta_cl` and `bin_cl` (the diversity θ and the
+  bin size in bp the decoder used) and `meta` (mean mutation rate, mean recombination rate,
+  number of sites, sequence length, seconds, and four counters). `builder/` has the scripts that made them and
+  `logs.tar` their logs.
+
+## Additional files (`additional/`)
+
+- `sample_size_levels/` has the summary statistics and PSMC+ posteriors for 1, 2, 4, 8 and 16
+  individuals (the first individuals of the same permutation). They were built for an earlier
+  design in which the network read a variable number of individuals; the final network reads 32.
+- `psmcplus_converged/` has a PSMC+ posterior whose prior was refitted five times in a row
+  instead of once, for 13,500 windows: a 12,500-window training subset spread evenly over
+  variant counts, and the 500 validation and 500 test windows. The scripts and checks that made
+  it are included.
+
+## Generator (`generator/`)
+
+`generator/code/` is the simulator exactly as it ran (MIT licence), and `corpus_plan.json` the
+generation plan: configuration, seeds, and checksums of the maps and templates. The simulator
+shipped third-party data files: the deCODE and Roulette maps, the published human histories and
+the stdpopsim trajectories. They are not copied here. `generator/EXCLUDED_THIRD_PARTY.tsv` lists
+each one with its size, SHA-256 and source. The scripts that build the deCODE map and the
+stdpopsim trajectories are in `generator/code/simulator/assets/`, and `generator/roulette_map/`
+has the script that averaged the published Roulette rates into the 1-kb map used here.
+
+## Checksums
+
+`sha256sum -c SHA256SUMS` checks every file. The checksums of the window files also match the
+receipts written when each file was generated (`windows/receipts.jsonl.gz`).
+
+## Paths in provenance files
+
+Logs, plans and other provenance files were written on the machines that ran the jobs. Absolute paths in them use
+placeholders: `$WORK` and `$DATA` for the working directories, `$SW` for installed software and `~` for the home
+directory. Checksums recorded inside the files match the released files.
+
+## Licence and sources
+
+The files here are released under CC BY 4.0. Please also cite the sources the windows build on:
+
+- msprime: Baumdicker et al. (2022), *Genetics* 220:iyab229.
+- deCODE recombination map: Halldorsson et al. (2019), *Science* 363:eaau1043.
+- Roulette mutation rates: Seplyarskiy et al. (2023), *Nature Genetics*.
+- Human size histories used as templates: Terhorst, Kamm and Song (2017), *Nature Genetics*
+  49:303 (SMC++); Terhorst (2025), *Nature Genetics* 57:2570 (phlash); Wang et al. (2020),
+  *PLOS Genetics* 16:e1008552 (MSMC-IM).
+- stdpopsim: Adrion et al. (2020), *eLife* 9:e54967.
+- PSMC+: Cousins et al. (2024), *bioRxiv*.
+
+## Citation
+
+The NeCast paper is in preparation; its reference will be added here.

additional/psmcplus_converged/RECEIPT.json

@@ -0,0 +1,166 @@
+{
+ "builder_is_bitwise_the_production_builder": {
+  "both_vs_the_stored_2026_09_06_artifact": "the same 4.9267e-07 on the refit mean, 2.468e-07 on the plain mean, 1.54413e-06 max over all 128 columns of a block",
+  "conclusion": "this builder reproduces the production builder exactly; the residual is a property of the stored artifact against today's environment, not of the reimplementation.  The stored sidecar is therefore not bit-reproducible today by its own code either.  Cause not identified: PSMCplus/, ladder_spec.py, psmc_exact.py, psmcplus_sidecar.py and the ctdd conda environment all predate 2026-09-06 unchanged, the decode gives the same bits on Intel Gold 6148, Cascadelake, AMD EPYC 7702 and AMD EPYC 9655, and the residual does not cluster by node nor correlate with variant count.",
+  "my_iterate_1_mean_vs_its_plain_mean": "BITWISE IDENTICAL",
+  "my_iterate_2_mean_vs_its_refit_mean": "BITWISE IDENTICAL",
+  "test": "the UNMODIFIED production builder $DATA/DLCoalSim/psmcplus_ladder.py was rerun today on one row (inventory index 2370, sim_00002386, registry row 2271) into a scratch output dir, all 24 (chain, level) pairs, 1,261 s"
+ },
+ "checks": {
+  "amplitude_500_5k_log10ne_sd": {
+   "band_bins": [
+    17,
+    32
+   ],
+   "converged_iterate6_mean_sd": 0.31738618313207767,
+   "median_ratio": 1.3284331298074532,
+   "stored_refit_iterate2_mean_sd": 0.2628786060618472
+  },
+  "converged_vs_stored_refit_max_abs_occupancy_diff": {
+   "max": 0.08005288243293762,
+   "median": 0.01004735566675663
+  },
+  "diploids_scored": {
+   "plain_all_32": false,
+   "plain_min": 30,
+   "refit_all_32": false,
+   "refit_min": 30
+  },
+  "finite": true,
+  "iterates_reached": {
+   "all_rows_reached_6": false,
+   "histogram": {
+    "4": 1,
+    "5": 1,
+    "6": 13498
+   },
+   "rows_with_stored_refit_carried_through_flag_minus_1": 0
+  },
+  "mean_block_sums_to_one_max_abs_error": 3.696311523526674e-08,
+  "means_nonnegative": true,
+  "plain_block_vs_stored": {
+   "bitwise_identical_rows": 5523,
+   "max_abs_diff": 1.691281795501709e-06,
+   "note": "recorded, then the STORED plain block is copied into the output so the variant differs from production in exactly the 128 refit columns"
+  },
+  "reproduction_of_stored_iterates_1_and_2": {
+   "bitwise_identical_rows": 4928,
+   "max": 2.9653310775756836e-06,
+   "median": 7.450580596923828e-09,
+   "metric": "max |mine - stored| over all 128 columns of the plain block and of the refit block, float32",
+   "p99": 4.954636096954346e-07,
+   "relative_to_the_change_being_made": "compare with converged_vs_stored_refit_max_abs_occupancy_diff below",
+   "rows_over_1e-4": 0,
+   "rows_over_1e-5": 0,
+   "rows_over_1e-8": 6248
+  },
+  "rows": 13500,
+  "sd_nonnegative": true,
+  "tolerance_violations": []
+ },
+ "files": {
+  "dropin/chain0_level32.npz": {
+   "bytes": 107621430,
+   "note": "production values on every row the build did not cover; converged refit on the built rows; production present flags, so the runner's normalisation moments mix stored and converged rows",
+   "present_rows": 104996,
+   "present_sha256_bool_as_the_runner_reads_it": "c4e31d9b42a839fef1f9f158fd70ef3079e33fcb6dfc5bb38c43c54ec97e14cf",
+   "sha256": "3b44482f739e0da4fc46c702eb22b0c97fccb80325d555f50748222ccbddb63a",
+   "sidecar_sha256_float64_as_the_runner_reads_it": "a4c09638f3bac6e84a7ad6b2800606ed29106cd325dead2397ca519b4cafb397"
+  },
+  "meanfill/chain0_level32.npz": {
+   "bytes": 107621430,
+   "note": "converged refit on the built rows; every other row set to the built-fit mean of the converged vectors, so the runner's normalisation mean is exactly the built rows' mean and every column's SD is scaled by the same sqrt(n_built_fit/89996)",
+   "present_rows": 104996,
+   "present_sha256_bool_as_the_runner_reads_it": "c4e31d9b42a839fef1f9f158fd70ef3079e33fcb6dfc5bb38c43c54ec97e14cf",
+   "sha256": "ef67fb185db3cc72133d9a88503c14b29ad4ce942bdda7c792c57297db6f64aa",
+   "sidecar_sha256_float64_as_the_runner_reads_it": "5ca4354af182bacd44bf81a43a91d6f9ad7af46322e37bc6c3d17ce4a140df42"
+  },
+  "meanfill_baseline/chain0_level32.npz": {
+   "bytes": 107621430,
+   "note": "the matched control for meanfill: STORED values on the built rows, every other row set to the stored built-fit mean; identical fill construction, so the two arms differ only in the refit",
+   "present_rows": 104996,
+   "present_sha256_bool_as_the_runner_reads_it": "c4e31d9b42a839fef1f9f158fd70ef3079e33fcb6dfc5bb38c43c54ec97e14cf",
+   "sha256": "1aa9f6b66ce60f682509d0ebed70c82112b8a5f0d1d6d9cc979dbdce5faa36e9",
+   "sidecar_sha256_float64_as_the_runner_reads_it": "68afd4fff329c3799ec02be3a510cb6648526375488cb780b4d864dbcc6b07e4"
+  }
+ },
+ "inputs": {
+  "fragments": "$DATA/DLCoalSim/prod_30mb_110k_128hap_20260824/samples/.fragments",
+  "plan": "$WORK/compshare_archive_20260916/files/runs/fixed32_fit89996_inner500_eval500_d128_e12_seed20260728/PLAN.json",
+  "production_builder_copied_verbatim": "$DATA/DLCoalSim/psmcplus_ladder.py",
+  "production_run_sidecar_sha256": "a40187ce360e422d3b059b8aa58d8ecf0f3c1ca9f18f95eb69830e0f610f6dec",
+  "psmcplus": "$DATA/DLCoalSim/PSMCplus",
+  "registry": "$WORK/registry109k",
+  "sidecar_module": "$WORK/src_20260903/training/psmcplus_sidecar.py",
+  "stored_sidecar": "$WORK/sidecar109k/chain0_level32.npz",
+  "stored_sidecar_sha256": "a40187ce360e422d3b059b8aa58d8ecf0f3c1ca9f18f95eb69830e0f610f6dec"
+ },
+ "iteration": {
+  "definition": "lambda_1 = 1 (plain decode); lambda_{k+1,b} = N0 / 10^occ_to_ne(pooled occupancy of iterate k)_b, clipped to [0.05, 50] by the decoder; pooled = mean over the level's scored diploids",
+  "iterates_total": 6,
+  "layout": {
+   "0:64": "iterate 1 pooled mean (unchanged from production)",
+   "128:192": "iterate 6 pooled mean",
+   "192:256": "iterate 6 population SD",
+   "64:128": "iterate 1 population SD (unchanged from production)"
+  },
+  "stored_production_file_is": "iterates 1 and 2 of the same recursion"
+ },
+ "patch_npz": {
+  "bytes": 36898552,
+  "path": "$WORK/sidecar109k_converged_20260916/patch.npz",
+  "sha256": "8a469373454b7102b71d5bc9fa221d3be3ad8189036c4aa9687db6a21b7d409f"
+ },
+ "per_row_checks_csv": {
+  "bytes": 1048594,
+  "path": "$WORK/sidecar109k_converged_20260916/per_row_checks.csv",
+  "sha256": "d37f0c4bb279f2cf309d84031414f43b18402d7ba07fdef39967f75c4a921fe2"
+ },
+ "rebuild": {
+  "assemble": "cd $WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant && ~/micromamba/envs/ctdd/bin/python -u assemble_converged.py",
+  "build": "cd $WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant && sbatch build.slurm     # array 0-199%184, 1 cpu / 16G / 4 h each, requeues itself; env PSMC_ITERATES=6 PSMC_WARM_START=0 PSMC_ROWS_NPZ=$PWD/pilot_rows_12500.npz PSMC_OUT=$WORK/sidecar109k_converged_20260916/shards",
+  "one_row_by_hand": "cd $WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant && PSMC_ROWS_NPZ=$PWD/probe_rows.npz PSMC_ITERATES=6 PSMC_TIME_ONLY=1 PSMC_OUT=/tmp/x ~/micromamba/envs/ctdd/bin/python -u psmcplus_converged.py 0 8",
+  "select_rows": "cd $WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant && ~/micromamba/envs/ctdd/bin/python -u select_pilot_rows.py . 12500"
+ },
+ "row_order": "identical to sidecar109k/chain0_level32.npz: cohort109k sample_id order, split_code != 2, ascending, 104,996 rows; sidecar row i describes cache row i and registry row i",
+ "row_set": {
+  "candidate_pool_sha256": "d571bd350f9fc0c7ddf91a02a29b9705c99b2ce7272c7c3545c40485e54843d7",
+  "one_logical_root": "the registry has a single logical_dataset_root, so the rule reduces to: sort the 89,996 fit rows by (variant_count, canonical_id) and take np.linspace(0, 89995, 12500) positions",
+  "pilot_evaluation_rows": 500,
+  "pilot_evaluation_sha256": "89b266b21d80790ee1cd0e65315a9e567949e4df3c42eb94aa038e2b311b7c2f",
+  "pilot_fit_rows": 12500,
+  "pilot_fit_sha256": "c22183c23581f840ebcd0f5f5098c6f707e1a46419a14776183cf7700e4c7e13",
+  "pilot_inner_rows": 500,
+  "pilot_inner_sha256": "efb80b6c6bb63a378f1645e9c8cd2a296b65f3a97bd9e753744fb3df749a9699",
+  "rule": "carrier_raw_runner._select_stage_rows(stage='pilot') -> _balanced_quantiles(reverse[fit], rows, --pilot-fit-rows) on the registry109k rows, candidates = PLAN stage_rows['fit'] of the production run (its --pilot-fit-rows 89996 == len(fit) took the census branch, so that list IS reverse[fit])",
+  "rule_copy_verified": "select_pilot_rows.balanced_quantiles / root_key are AST-identical to deploy_20260913_fixed32 carrier_raw_runner._balanced_quantiles / _root_key apart from type annotations and the leading underscore; and the census branch (count == len(candidates)) reproduces the production run's stage_rows_identity.fit sha256 exactly",
+  "sealed_rows_in_selection": 0,
+  "sealed_rows_read": 0,
+  "union_sha256": "05eea0a41793a0bc92d7a181ceb793272276d1b7c099b9dafa338f0b74a790c8"
+ },
+ "rows_built": 13500,
+ "rows_missing": [],
+ "rows_missing_count": 0,
+ "rows_requested": 13500,
+ "runner_notes": {
+  "basename_is_load_bearing": "fixed_view.SIDECAR_BASENAME == 'chain0_level32.npz'; the runner refuses any other filename, so each variant lives in its own directory",
+  "coverage_floor": "MINIMUM_SIDECAR_COVERAGE = 0.90 of the fit rows; flagging the 77,496 un-rebuilt fit rows absent would be 0.139 and the frozen runner would refuse, which is why meanfill exists",
+  "how_the_run_reads_it": "--sidecar-npz /path/to/<variant>/chain0_level32.npz, with --arms raw_plus_all_sidecar",
+  "normalisation": "carrier_raw_summary_fusion_runner._load_sidecar centres and scales on fit & present rows, where fit is the FULL 89,996-row architecture-fit split, not the pilot subset",
+  "verify_cohort_artifacts_will_flag_this_on_purpose": "check [5] wants chain0_level{1,2,4,8,16,32}.npz and a RECEIPT_chain0.json in one directory, and these variant directories hold only the level-32 file the run reads; check [6] compares every value against the psmcplus_ladder store, and the refit half of the rebuilt rows is meant to differ.  Run that script against sidecar109k/, not against these."
+ },
+ "status": "complete",
+ "stored_sidecar_is_the_one_the_production_run_read": true,
+ "transfer_to_compshare": {
+  "alternative": "ship a whole variant file (108 MB, ~83 s)",
+  "destination": "/cloud/cloud-ssd1/dlcoal/ablation_20260916/sidecars/<variant>/chain0_level32.npz -- the path the ablation harness on that box already expects (its README: 'alternative sidecars live here', beside the existing ctrl_same_bytes symlink).  Suggested variant directory names: converged_refit6 (from dropin/), and converged_refit6_meanfill / stored_refit2_meanfill for the strict pair.  sidecar109k/ is never written.",
+  "recommended": "ship patch.npz (36.9 MB, ~28 s) and rebuild the full file on Compshare with apply_patch.py against /cloud/cloud-ssd1/dlcoal/sidecar109k/chain0_level32.npz",
+  "relay": "~1.3 MB/s via the local machine (no direct cluster<->Compshare route)",
+  "stored_file_on_compshare_is_the_same_bytes": "sha256 a40187ce360e422d3b059b8aa58d8ecf0f3c1ca9f18f95eb69830e0f610f6dec on Compshare, on the cluster, and in the production run's PLAN -- so apply_patch.py's plain-block check passes there (verified by reading, 2026-09-16)"
+ },
+ "what": "converged-PSMC+ sidecar variant, chain 0 / level 32, for the (a) training ablation",
+ "which_variant_to_use": {
+  "default": "dropin -- the runner's normalisation moments stay within a percent of the production file's (measured: normalised built rows rms 1.024 against 0.998, per-column SD ratio median 0.995), so the arm differs from the production run essentially only in the refit values of the rows it trains on.  Compare it against sidecar109k/chain0_level32.npz.",
+  "strict": "meanfill against meanfill_baseline -- an exact A/B: identical fill construction, so the runner's mean is exactly the built-fit mean and every column's SD is scaled by the same sqrt(n_built_fit/89996).  Both arms carry that one scalar input gain (2.68x at 12,500 built fit rows), so it cancels between them but they are NOT comparable to the production run."
+ }
+}

additional/psmcplus_converged/apply_patch.py

@@ -0,0 +1,82 @@
+"""Rebuild a converged-sidecar variant on any host from patch.npz + the production sidecar.
+
+The production file is read only.  The output is written into a NEW directory and is always
+named chain0_level32.npz, because the frozen runner refuses any other basename
+(training/fixed_view.py: SIDECAR_BASENAME = f"chain{VIEW_CHAIN}_level{VIEW_DIPLOIDS}.npz").
+
+Variants (see RECEIPT.json for why meanfill exists):
+  dropin            production values on every un-rebuilt row, converged refit on the rebuilt ones
+  meanfill          converged refit on the rebuilt rows; every other row = the rebuilt-fit mean of
+                    the converged vectors
+  meanfill_baseline the matched control: stored values on the rebuilt rows; every other row = the
+                    rebuilt-fit mean of the stored vectors
+
+Usage:
+  python apply_patch.py --stored /cloud/cloud-ssd1/dlcoal/sidecar109k/chain0_level32.npz \
+                        --patch  patch.npz \
+                        --out    /cloud/cloud-ssd1/dlcoal/sidecar109k_converged_20260916 \
+                        --variant dropin --variant meanfill --variant meanfill_baseline
+"""
+import argparse, hashlib, json, os
+import numpy as np
+
+FEAT = 256
+BASENAME = "chain0_level32.npz"
+
+
+def sha256_file(path, chunk=1 << 22):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(chunk), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--stored", required=True)
+ap.add_argument("--patch", required=True)
+ap.add_argument("--out", required=True)
+ap.add_argument("--variant", action="append", default=None,
+                choices=["dropin", "meanfill", "meanfill_baseline"])
+A = ap.parse_args()
+variants = A.variant or ["dropin"]
+
+store = np.load(A.stored, allow_pickle=False)
+stored = store["sidecar"].astype(np.float32)
+present = store["sidecar_present"]
+patch = np.load(A.patch, allow_pickle=False)
+reg = patch["registry_index"].astype(np.int64)
+feats = patch["features"].astype(np.float32)
+pilot_fit = patch["pilot_fit"].astype(np.int64)
+assert stored.ndim == 2 and stored.shape[1] == FEAT, stored.shape
+assert feats.shape == (len(reg), FEAT)
+assert reg.min() >= 0 and reg.max() < len(stored), "the patch does not fit this cohort"
+assert len(np.unique(reg)) == len(reg)
+# the patch leaves the plain half of every rebuilt row exactly as production had it
+assert np.array_equal(feats[:, 0:128], stored[reg][:, 0:128]), \
+    "patch plain block differs from the stored file: wrong production sidecar"
+built_fit = np.asarray(sorted(set(pilot_fit.tolist()) & set(reg.tolist())), dtype=np.int64)
+os.makedirs(A.out, exist_ok=True)
+report = {"stored": A.stored, "stored_sha256": sha256_file(A.stored), "patch": A.patch,
+          "patch_sha256": sha256_file(A.patch), "rows": int(len(stored)),
+          "rows_patched": int(len(reg)), "built_fit_rows": int(len(built_fit)), "written": {}}
+
+for name in variants:
+    if name == "dropin":
+        values = stored.copy(); values[reg] = feats
+    elif name == "meanfill":
+        fill = feats[np.isin(reg, built_fit)].mean(axis=0)
+        values = np.repeat(fill[None, :], len(stored), axis=0).astype(np.float32); values[reg] = feats
+    else:
+        fill = stored[built_fit].mean(axis=0)
+        values = np.repeat(fill[None, :], len(stored), axis=0).astype(np.float32)
+        values[reg] = stored[reg]
+    assert np.isfinite(values).all()
+    d = os.path.join(A.out, name); os.makedirs(d, exist_ok=True)
+    p = os.path.join(d, BASENAME)
+    np.savez(p, sidecar=values, sidecar_present=np.asarray(present).astype(np.uint8))
+    report["written"][name] = {"path": p, "sha256": sha256_file(p), "bytes": os.path.getsize(p)}
+    print("wrote", p)
+
+json.dump(report, open(os.path.join(A.out, "APPLY_PATCH.json"), "w"), indent=1, sort_keys=True)
+print(json.dumps(report, indent=1, sort_keys=True))

additional/psmcplus_converged/assemble_converged.py

@@ -0,0 +1,394 @@
+"""Assemble the converged-PSMC+ sidecar variant from the per-task shards, with a receipt.
+
+Writes, under $WORK/sidecar109k_converged_20260916/ :
+
+  patch.npz                      the built rows only: registry_index, sample_id, features(256),
+                                 flags, meta, iterate_means(K,64).  ~14 MB, the thing to relay.
+  dropin/chain0_level32.npz      104,996 x 256, production values everywhere, converged refit on
+                                 the built rows; sidecar_present copied from production.
+  meanfill/chain0_level32.npz    converged refit on the built rows; EVERY OTHER ROW set to the
+                                 built-fit mean of the converged vectors.
+  meanfill_baseline/chain0_level32.npz
+                                 the matched control for meanfill: the STORED values on the built
+                                 rows, every other row set to the stored built-fit mean.
+  RECEIPT.json
+
+Why meanfill exists.  The frozen runner normalises the sidecar over ALL 89,996 architecture-fit
+rows (carrier_raw_summary_fusion_runner._load_sidecar, fit= the full split), and refuses a file
+whose sidecar_present covers under 90% of them (MINIMUM_SIDECAR_COVERAGE = 0.90), so the honest
+"flag the un-rebuilt rows absent" route is not available without a new deploy.  Filling the
+un-rebuilt rows with the built rows' own fit mean is the same imputation the runner itself applies
+to absent rows, expressed in raw values: it makes the normalisation mean EXACTLY the built rows'
+mean, and multiplies every column's SD by the same constant sqrt(n_built_fit / 89,996), i.e. one
+scalar gain on the whole stream -- identical in the variant and in its matched baseline, so the
+A/B stays clean.  dropin/ is the simpler file for anyone who prefers production values elsewhere
+and accepts mixed normalisation moments.
+
+Usage: python assemble_converged.py [--out DIR]
+"""
+import glob, hashlib, json, os, sys
+import numpy as np
+
+A = "$WORK"
+OUTROOT = A + "/sidecar109k_converged_20260916"
+SHARDS = OUTROOT + "/shards"
+STORED = A + "/sidecar109k/chain0_level32.npz"
+WORK = A + "/bench_h2h_20260915/analysis/final_round/sidecar_variant"
+ROWS_NPZ = WORK + "/pilot_rows_12500.npz"
+RUN = A + "/compshare_archive_20260916/files/runs/fixed32_fit89996_inner500_eval500_d128_e12_seed20260728"
+FEAT, NB = 256, 64
+BASENAME = "chain0_level32.npz"
+
+
+def sha256_file(path, chunk=1 << 22):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(chunk), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def array_sha256(value):                                   # training/data.py::_array_sha256
+    array = np.ascontiguousarray(value)
+    digest = hashlib.sha256()
+    digest.update(array.dtype.str.encode("ascii"))
+    digest.update(json.dumps(array.shape).encode("ascii"))
+    digest.update(memoryview(array).cast("B"))
+    return digest.hexdigest()
+
+
+sys.path.insert(0, "$DATA/DLCoalSim/train-deploy-20260826-carrier-raw-v76-tap-label")
+from simulator.utils import time_grid
+from simulator.config import Config
+edges_gen, _ = time_grid(Config())
+edges_gen = np.asarray(edges_gen, float)
+dt = np.diff(edges_gen)
+assert len(dt) == NB
+
+
+def occ_to_ne(occ):                                        # psmc_exact.py, verbatim
+    f = np.maximum(occ, 1e-12); f = f / f.sum()
+    surv = 1.0 - np.concatenate([[0.0], np.cumsum(f)[:-1]])
+    eta = f / (dt * np.maximum(surv, 1e-6))
+    return np.log10(1.0 / (2.0 * np.maximum(eta, 1e-12)))
+
+
+RL = np.load(ROWS_NPZ, allow_pickle=False)
+want_reg = RL["registry_index"].astype(np.int64)
+want_sid = np.asarray(RL["sample_id"]).astype(str)
+kind = RL["kind"].astype(np.int8)
+pilot_fit = RL["pilot_fit"].astype(np.int64)
+sid_of_reg = {int(r): s for r, s in zip(want_reg.tolist(), want_sid.tolist())}
+
+store = np.load(STORED, allow_pickle=False)
+stored_sidecar = store["sidecar"].astype(np.float32)
+stored_present = store["sidecar_present"]
+NROWS = stored_sidecar.shape[0]
+assert stored_sidecar.shape == (NROWS, FEAT)
+
+reg_seen, feats, flags, metas, iters = [], [], [], [], []
+K = None
+for path in sorted(glob.glob(SHARDS + "/shard_*.npz")):
+    try:
+        z = np.load(path, allow_pickle=False)
+    except BaseException as error:
+        print(f"skip unreadable shard {path}: {error!r}")
+        continue
+    if "registry_index" not in z.files or len(z["registry_index"]) == 0:
+        continue
+    K = int(z["iterates"]) if K is None else K
+    assert int(z["iterates"]) == K, (path, "shard built with a different iterate count")
+    assert int(z["warm_start"]) == 0, (path, "shard is warm-started; the receipt claims cold")
+    reg_seen.extend(z["registry_index"].tolist())
+    feats.append(z["features"]); flags.append(z["flags"])
+    metas.append(z["meta"]); iters.append(z["iterate_means"])
+
+reg_seen = np.asarray(reg_seen, dtype=np.int64)
+order = np.argsort(reg_seen, kind="stable")           # cache identity order == ascending registry index
+reg_seen = reg_seen[order]
+feats = np.concatenate(feats, axis=0)[order]
+flags = np.concatenate(flags, axis=0)[order]
+metas = np.concatenate(metas, axis=0)[order]
+iters = np.concatenate(iters, axis=0)[order]
+assert len(np.unique(reg_seen)) == len(reg_seen), "a row was built twice"
+assert set(reg_seen.tolist()).issubset(set(want_reg.tolist())), "a shard holds a row outside the list"
+
+built = set(reg_seen.tolist())
+missing = [int(r) for r in want_reg.tolist() if r not in built]
+built_fit = np.asarray(sorted(set(pilot_fit.tolist()) & built), dtype=np.int64)
+print(f"built {len(reg_seen)} of {len(want_reg)} rows ({len(missing)} missing); "
+      f"pilot-fit built {len(built_fit)} of {len(pilot_fit)}")
+
+# ---------------------------------------------------------------- per-row checks
+max_repro = metas[:, 10]
+plain_scored, refit_scored = flags[:, 0].astype(int), flags[:, 1].astype(int)
+mean_blocks = np.stack([feats[:, 0:64], feats[:, 128:192]], axis=1).astype(np.float64)
+sd_blocks = np.stack([feats[:, 64:128], feats[:, 192:256]], axis=1).astype(np.float64)
+checks = {
+    "rows": int(len(reg_seen)),
+    "reproduction_of_stored_iterates_1_and_2": {
+        "metric": "max |mine - stored| over all 128 columns of the plain block and of the refit block, float32",
+        "bitwise_identical_rows": int((max_repro == 0.0).sum()),
+        "max": float(max_repro.max()), "median": float(np.median(max_repro)),
+        "p99": float(np.percentile(max_repro, 99)),
+        "rows_over_1e-8": int((max_repro > 1e-8).sum()),
+        "rows_over_1e-5": int((max_repro > 1e-5).sum()),
+        "rows_over_1e-4": int((max_repro > 1e-4).sum()),
+        "relative_to_the_change_being_made": "compare with converged_vs_stored_refit_max_abs_occupancy_diff below",
+    },
+    "diploids_scored": {
+        "plain_all_32": bool((plain_scored == 32).all()), "refit_all_32": bool((refit_scored == 32).all()),
+        "plain_min": int(plain_scored.min()), "refit_min": int(refit_scored.min()),
+    },
+    "finite": bool(np.isfinite(feats).all()),
+    "means_nonnegative": bool((mean_blocks >= 0).all()),
+    "sd_nonnegative": bool((sd_blocks >= 0).all()),
+    "mean_block_sums_to_one_max_abs_error": float(np.abs(mean_blocks.sum(axis=2) - 1.0).max()),
+    "plain_block_vs_stored": {
+        "bitwise_identical_rows": int(
+            (np.abs(feats[:, 0:128].astype(np.float64)
+                    - stored_sidecar[reg_seen][:, 0:128].astype(np.float64)).max(axis=1) == 0.0).sum()
+        ),
+        "max_abs_diff": float(np.abs(feats[:, 0:128].astype(np.float64)
+                                     - stored_sidecar[reg_seen][:, 0:128].astype(np.float64)).max()),
+        "note": "recorded, then the STORED plain block is copied into the output so the variant "
+                "differs from production in exactly the 128 refit columns",
+    },
+}
+# what the extra iterates bought, as log10 Ne amplitude in 500-5,000 generations
+band = np.flatnonzero((edges_gen[:-1] >= 500.0) & (edges_gen[:-1] < 5000.0))
+ne_stored = np.apply_along_axis(occ_to_ne, 1, stored_sidecar[reg_seen][:, 128:192].astype(np.float64))
+ne_conv = np.apply_along_axis(occ_to_ne, 1, feats[:, 128:192].astype(np.float64))
+checks["amplitude_500_5k_log10ne_sd"] = {
+    "band_bins": [int(band.min()), int(band.max())],
+    "stored_refit_iterate2_mean_sd": float(ne_stored[:, band].std(axis=1).mean()),
+    "converged_iterate%d_mean_sd" % K: float(ne_conv[:, band].std(axis=1).mean()),
+    "median_ratio": float(np.median(ne_conv[:, band].std(axis=1) / np.maximum(ne_stored[:, band].std(axis=1), 1e-12))),
+}
+# how far each row actually iterated: a row that stopped early leaves trailing zero rows
+reached = np.array([int(np.max(np.flatnonzero(iters[i].any(axis=1))) + 1) for i in range(len(iters))])
+checks["iterates_reached"] = {
+    "all_rows_reached_%d" % K: bool((reached == K).all()),
+    "histogram": {str(int(v)): int(c) for v, c in zip(*np.unique(reached, return_counts=True))},
+    "rows_with_stored_refit_carried_through_flag_minus_1": int((flags[:, 1] == -1).sum()),
+}
+checks["converged_vs_stored_refit_max_abs_occupancy_diff"] = {
+    "median": float(np.median(np.abs(feats[:, 128:192] - stored_sidecar[reg_seen][:, 128:192]).max(axis=1))),
+    "max": float(np.abs(feats[:, 128:192] - stored_sidecar[reg_seen][:, 128:192]).max()),
+}
+print(json.dumps(checks, indent=1))
+# Tolerance, not bitwise, and RECORDED rather than asserted: this script runs unattended after the
+# array, and a file plus a receipt that says a tolerance was exceeded beats no file at all.  The
+# decode is a 10^5-10^6 step forward-backward recursion in compiled kernels, so a rerun can differ
+# in the last places and the drift accumulates along the sequence; what matters is that it stays
+# orders of magnitude below the change being made, which the two numbers here let a reader check.
+violations = []
+if not checks["finite"]:
+    violations.append("nonfinite values in the built rows")
+if checks["plain_block_vs_stored"]["max_abs_diff"] >= 1e-4:
+    violations.append("plain block differs from production by >= 1e-4")
+if checks["reproduction_of_stored_iterates_1_and_2"]["rows_over_1e-4"]:
+    violations.append("%d rows reproduce the stored columns only to worse than 1e-4"
+                      % checks["reproduction_of_stored_iterates_1_and_2"]["rows_over_1e-4"])
+checks["tolerance_violations"] = violations
+if violations:
+    print("WARNING: " + "; ".join(violations))
+assert checks["finite"], "refusing to write nonfinite values"
+# the variant differs from production in exactly the refit half: carry the stored plain half through
+feats[:, 0:128] = stored_sidecar[reg_seen][:, 0:128]
+
+os.makedirs(OUTROOT, exist_ok=True)
+np.savez(OUTROOT + "/patch.npz",
+         registry_index=reg_seen,
+         sample_id=np.asarray([sid_of_reg[int(r)] for r in reg_seen.tolist()]),
+         features=feats.astype(np.float32), flags=flags.astype(np.int16), meta=metas,
+         # every iterate's POOLED MEAN is kept (so any K <= this one can be re-derived); the
+         # population SD is kept only for iterate 1 and for the last iterate each row reached,
+         # in features[64:128] and features[192:256]
+         iterate_means=iters.astype(np.float32), iterates=np.int32(K),
+         pilot_fit=pilot_fit, pilot_inner=RL["pilot_inner"], pilot_evaluation=RL["pilot_evaluation"],
+         kind=kind, union_registry_index=want_reg)
+
+# A per-row receipt, readable without numpy.  meta columns are, in order:
+# mu, r, variant_count, sequence_length, seconds, theta, BIN, N0, j_max, cold_recomb_segments,
+# max_repro, iterate_seconds_total
+with open(OUTROOT + "/per_row_checks.csv", "w") as handle:
+    handle.write("registry_index,sample_id,variant_count,theta,bin_bp,j_max,plain_scored,refit_scored,"
+                 "iterates_reached,max_abs_diff_vs_stored_iterates_1_2,max_abs_diff_converged_vs_stored_refit,"
+                 "seconds\n")
+    conv_delta = np.abs(feats[:, 128:192].astype(np.float64)
+                        - stored_sidecar[reg_seen][:, 128:192].astype(np.float64)).max(axis=1)
+    for i, r in enumerate(reg_seen.tolist()):
+        handle.write("%d,%s,%d,%.8g,%d,%d,%d,%d,%d,%.6g,%.6g,%.1f\n" % (
+            r, sid_of_reg[int(r)], int(metas[i, 2]), metas[i, 5], int(metas[i, 6]), int(metas[i, 8]),
+            int(flags[i, 0]), int(flags[i, 1]), int(reached[i]), max_repro[i], conv_delta[i], metas[i, 4]))
+print("per-row receipt ->", OUTROOT + "/per_row_checks.csv")
+
+files = {}
+
+
+def write_variant(subdir, values, present, note):
+    os.makedirs(OUTROOT + "/" + subdir, exist_ok=True)
+    path = f"{OUTROOT}/{subdir}/{BASENAME}"
+    np.savez(path, sidecar=values.astype(np.float32), sidecar_present=np.asarray(present).astype(np.uint8))
+    files[subdir + "/" + BASENAME] = {
+        "sha256": sha256_file(path), "bytes": os.path.getsize(path),
+        "sidecar_sha256_float64_as_the_runner_reads_it": array_sha256(values.astype(np.float32).astype(np.float64)),
+        "present_sha256_bool_as_the_runner_reads_it": array_sha256(np.asarray(present).astype(bool)),
+        "present_rows": int(np.count_nonzero(np.asarray(present))), "note": note,
+    }
+    print(f"wrote {path}")
+
+
+dropin = stored_sidecar.copy()
+dropin[reg_seen] = feats
+write_variant("dropin", dropin, stored_present,
+              "production values on every row the build did not cover; converged refit on the built rows; "
+              "production present flags, so the runner's normalisation moments mix stored and converged rows")
+
+conv_fit_mean = feats[np.isin(reg_seen, built_fit)].mean(axis=0)
+meanfill = np.repeat(conv_fit_mean[None, :], NROWS, axis=0).astype(np.float32)
+meanfill[reg_seen] = feats
+write_variant("meanfill", meanfill, stored_present,
+              "converged refit on the built rows; every other row set to the built-fit mean of the converged "
+              "vectors, so the runner's normalisation mean is exactly the built rows' mean and every column's "
+              "SD is scaled by the same sqrt(n_built_fit/89996)")
+
+stored_fit_mean = stored_sidecar[built_fit].mean(axis=0)
+base = np.repeat(stored_fit_mean[None, :], NROWS, axis=0).astype(np.float32)
+base[reg_seen] = stored_sidecar[reg_seen]
+write_variant("meanfill_baseline", base, stored_present,
+              "the matched control for meanfill: STORED values on the built rows, every other row set to the "
+              "stored built-fit mean; identical fill construction, so the two arms differ only in the refit")
+
+plan = json.load(open(RUN + "/PLAN.json"))
+stored_sha = sha256_file(STORED)
+plan_sidecar_sha = plan["evidence_identity"]["sidecar"]["file_sha256"]
+receipt = {
+    "stored_sidecar_is_the_one_the_production_run_read": bool(stored_sha == plan_sidecar_sha),
+    "what": "converged-PSMC+ sidecar variant, chain 0 / level 32, for the (a) training ablation",
+    "iteration": {
+        "definition": "lambda_1 = 1 (plain decode); lambda_{k+1,b} = N0 / 10^occ_to_ne(pooled occupancy of iterate k)_b, "
+                      "clipped to [0.05, 50] by the decoder; pooled = mean over the level's scored diploids",
+        "iterates_total": int(K),
+        "stored_production_file_is": "iterates 1 and 2 of the same recursion",
+        "layout": {"0:64": "iterate 1 pooled mean (unchanged from production)",
+                   "64:128": "iterate 1 population SD (unchanged from production)",
+                   "128:192": "iterate %d pooled mean" % K,
+                   "192:256": "iterate %d population SD" % K},
+    },
+    "row_order": "identical to sidecar109k/chain0_level32.npz: cohort109k sample_id order, split_code != 2, "
+                 "ascending, 104,996 rows; sidecar row i describes cache row i and registry row i",
+    "rows_built": int(len(reg_seen)),
+    "rows_requested": int(len(want_reg)),
+    "rows_missing": missing[:200],
+    "rows_missing_count": len(missing),
+    "row_set": {
+        "rule": "carrier_raw_runner._select_stage_rows(stage='pilot') -> _balanced_quantiles(reverse[fit], rows, "
+                "--pilot-fit-rows) on the registry109k rows, candidates = PLAN stage_rows['fit'] of the production "
+                "run (its --pilot-fit-rows 89996 == len(fit) took the census branch, so that list IS reverse[fit])",
+        "pilot_fit_rows": int(len(pilot_fit)),
+        "pilot_fit_sha256": array_sha256(pilot_fit),
+        "pilot_inner_rows": int(len(RL["pilot_inner"])), "pilot_inner_sha256": array_sha256(RL["pilot_inner"]),
+        "pilot_evaluation_rows": int(len(RL["pilot_evaluation"])),
+        "pilot_evaluation_sha256": array_sha256(RL["pilot_evaluation"]),
+        "union_sha256": array_sha256(want_reg),
+        "candidate_pool_sha256": plan["stage_rows_identity"]["fit"]["sha256"],
+        "sealed_rows_read": 0,
+        "sealed_rows_in_selection": 0,
+        "rule_copy_verified": "select_pilot_rows.balanced_quantiles / root_key are AST-identical to "
+            "deploy_20260913_fixed32 carrier_raw_runner._balanced_quantiles / _root_key apart from type "
+            "annotations and the leading underscore; and the census branch (count == len(candidates)) "
+            "reproduces the production run's stage_rows_identity.fit sha256 exactly",
+        "one_logical_root": "the registry has a single logical_dataset_root, so the rule reduces to: sort the "
+            "89,996 fit rows by (variant_count, canonical_id) and take np.linspace(0, 89995, 12500) positions",
+    },
+    "status": "complete" if (not missing and not violations) else "partial_or_flagged",
+    "builder_is_bitwise_the_production_builder": {
+        "test": "the UNMODIFIED production builder $DATA/DLCoalSim/psmcplus_ladder.py was rerun "
+                "today on one row (inventory index 2370, sim_00002386, registry row 2271) into a scratch "
+                "output dir, all 24 (chain, level) pairs, 1,261 s",
+        "my_iterate_1_mean_vs_its_plain_mean": "BITWISE IDENTICAL",
+        "my_iterate_2_mean_vs_its_refit_mean": "BITWISE IDENTICAL",
+        "both_vs_the_stored_2026_09_06_artifact": "the same 4.9267e-07 on the refit mean, 2.468e-07 on the "
+                "plain mean, 1.54413e-06 max over all 128 columns of a block",
+        "conclusion": "this builder reproduces the production builder exactly; the residual is a property of "
+                "the stored artifact against today's environment, not of the reimplementation.  The stored "
+                "sidecar is therefore not bit-reproducible today by its own code either.  Cause not "
+                "identified: PSMCplus/, ladder_spec.py, psmc_exact.py, psmcplus_sidecar.py and the ctdd conda "
+                "environment all predate 2026-09-06 unchanged, the decode gives the same bits on Intel Gold "
+                "6148, Cascadelake, AMD EPYC 7702 and AMD EPYC 9655, and the residual does not cluster by "
+                "node nor correlate with variant count.",
+    },
+    "checks": checks,
+    "inputs": {
+        "stored_sidecar": STORED, "stored_sidecar_sha256": stored_sha,
+        "production_run_sidecar_sha256": plan_sidecar_sha,
+        "fragments": "$DATA/DLCoalSim/prod_30mb_110k_128hap_20260824/samples/.fragments",
+        "psmcplus": "$DATA/DLCoalSim/PSMCplus",
+        "sidecar_module": "$WORK/src_20260903/training/psmcplus_sidecar.py",
+        "production_builder_copied_verbatim": "$DATA/DLCoalSim/psmcplus_ladder.py",
+        "registry": A + "/registry109k",
+        "plan": RUN + "/PLAN.json",
+    },
+    "files": files,
+    "patch_npz": {"path": OUTROOT + "/patch.npz", "sha256": sha256_file(OUTROOT + "/patch.npz"),
+                  "bytes": os.path.getsize(OUTROOT + "/patch.npz")},
+    "per_row_checks_csv": {"path": OUTROOT + "/per_row_checks.csv",
+                           "sha256": sha256_file(OUTROOT + "/per_row_checks.csv"),
+                           "bytes": os.path.getsize(OUTROOT + "/per_row_checks.csv")},
+    "rebuild": {
+        "select_rows": "cd %s && ~/micromamba/envs/ctdd/bin/python -u select_pilot_rows.py . 12500" % WORK,
+        "build": "cd %s && sbatch build.slurm     # array 0-199%%184, 1 cpu / 16G / 4 h each, requeues itself; "
+                 "env PSMC_ITERATES=6 PSMC_WARM_START=0 PSMC_ROWS_NPZ=$PWD/pilot_rows_12500.npz "
+                 "PSMC_OUT=%s" % (WORK, SHARDS),
+        "assemble": "cd %s && ~/micromamba/envs/ctdd/bin/python -u assemble_converged.py" % WORK,
+        "one_row_by_hand": "cd %s && PSMC_ROWS_NPZ=$PWD/probe_rows.npz PSMC_ITERATES=6 PSMC_TIME_ONLY=1 "
+                           "PSMC_OUT=/tmp/x ~/micromamba/envs/ctdd/bin/python -u "
+                           "psmcplus_converged.py 0 8" % WORK,
+    },
+    "transfer_to_compshare": {
+        "relay": "~1.3 MB/s via the local machine (no direct cluster<->Compshare route)",
+        "recommended": "ship patch.npz (%.1f MB, ~%.0f s) and rebuild the full file on Compshare with "
+                       "apply_patch.py against /cloud/cloud-ssd1/dlcoal/sidecar109k/chain0_level32.npz"
+                       % (os.path.getsize(OUTROOT + "/patch.npz") / 1e6,
+                          os.path.getsize(OUTROOT + "/patch.npz") / 1.3e6),
+        "alternative": "ship a whole variant file (%.0f MB, ~%.0f s)"
+                       % (os.path.getsize(f"{OUTROOT}/dropin/{BASENAME}") / 1e6,
+                          os.path.getsize(f"{OUTROOT}/dropin/{BASENAME}") / 1.3e6),
+        "destination": "/cloud/cloud-ssd1/dlcoal/ablation_20260916/sidecars/<variant>/chain0_level32.npz -- the "
+                       "path the ablation harness on that box already expects (its README: 'alternative sidecars "
+                       "live here', beside the existing ctrl_same_bytes symlink).  Suggested variant directory "
+                       "names: converged_refit6 (from dropin/), and converged_refit6_meanfill / "
+                       "stored_refit2_meanfill for the strict pair.  sidecar109k/ is never written.",
+        "stored_file_on_compshare_is_the_same_bytes": "sha256 a40187ce360e422d3b059b8aa58d8ecf0f3c1ca9f18f95eb69830e"
+                       "0f610f6dec on Compshare, on the cluster, and in the production run's PLAN -- so apply_patch.py's "
+                       "plain-block check passes there (verified by reading, 2026-09-16)",
+    },
+    "which_variant_to_use": {
+        "default": "dropin -- the runner's normalisation moments stay within a percent of the production "
+                   "file's (measured: normalised built rows rms 1.024 against 0.998, per-column SD ratio "
+                   "median 0.995), so the arm differs from the production run essentially only in the refit "
+                   "values of the rows it trains on.  Compare it against sidecar109k/chain0_level32.npz.",
+        "strict": "meanfill against meanfill_baseline -- an exact A/B: identical fill construction, so the "
+                  "runner's mean is exactly the built-fit mean and every column's SD is scaled by the same "
+                  "sqrt(n_built_fit/89996).  Both arms carry that one scalar input gain (2.68x at 12,500 "
+                  "built fit rows), so it cancels between them but they are NOT comparable to the "
+                  "production run.",
+    },
+    "runner_notes": {
+        "basename_is_load_bearing": "fixed_view.SIDECAR_BASENAME == 'chain0_level32.npz'; the runner refuses any "
+                                    "other filename, so each variant lives in its own directory",
+        "normalisation": "carrier_raw_summary_fusion_runner._load_sidecar centres and scales on fit & present rows, "
+                         "where fit is the FULL 89,996-row architecture-fit split, not the pilot subset",
+        "coverage_floor": "MINIMUM_SIDECAR_COVERAGE = 0.90 of the fit rows; flagging the 77,496 un-rebuilt fit rows "
+                          "absent would be 0.139 and the frozen runner would refuse, which is why meanfill exists",
+        "verify_cohort_artifacts_will_flag_this_on_purpose": "check [5] wants chain0_level{1,2,4,8,16,32}.npz and a "
+            "RECEIPT_chain0.json in one directory, and these variant directories hold only the level-32 file the "
+            "run reads; check [6] compares every value against the psmcplus_ladder store, and the refit half of the "
+            "rebuilt rows is meant to differ.  Run that script against sidecar109k/, not against these.",
+        "how_the_run_reads_it": "--sidecar-npz /path/to/<variant>/chain0_level32.npz, with --arms raw_plus_all_sidecar",
+    },
+}
+json.dump(receipt, open(OUTROOT + "/RECEIPT.json", "w"), indent=1, sort_keys=True)
+print("receipt ->", OUTROOT + "/RECEIPT.json")

additional/psmcplus_converged/build.slurm

@@ -0,0 +1,39 @@
+#!/bin/bash
+# Converged-PSMC+ sidecar (chain 0, level 32) over the 13,500 pilot rows.
+# The row -> task deal lives in psmcplus_converged.py:my_rows and is a SNAKE over descending
+# variant_count, so it is a pure function of (task, NTASK).  NTASK is FIXED at 200.
+# Each task rewrites its shard after EVERY row, skips rows it already holds on restart, stops
+# starting new rows before the wall (PSMC_BUDGET_S) and then requeues itself.  The requeue is
+# guarded three ways: python exit 0, the remaining-row count must have strictly decreased, and
+# SLURM_RESTART_COUNT under 8.
+#SBATCH --job-name=sc_conv
+#SBATCH --array=0-199%184
+#SBATCH --time=04:00:00
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=16G
+#SBATCH --requeue
+#SBATCH --open-mode=append
+#SBATCH --output=$WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant/logs/conv-%A_%a.out
+#SBATCH --error=$WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant/logs/conv-%A_%a.err
+export OMP_NUM_THREADS=1 MKL_NUM_THREADS=1 NUMBA_NUM_THREADS=1 OPENBLAS_NUM_THREADS=1
+D=$WORK/bench_h2h_20260915/analysis/final_round/sidecar_variant
+export PSMC_ROWS_NPZ=$D/pilot_rows_12500.npz
+export PSMC_OUT=$WORK/sidecar109k_converged_20260916/shards
+export PSMC_ITERATES=6
+export PSMC_WARM_START=0
+export PSMC_BUDGET_S=13200          # stop starting rows ~20 min before the 4 h wall
+NTASK=200
+PY=~/micromamba/envs/ctdd/bin/python
+mkdir -p "$PSMC_OUT" "$D/logs"
+cd $D
+
+int_or_zero() { case "$1" in ''|*[!0-9]*) echo 0 ;; *) echo "$1" ;; esac; }
+BEFORE=$(int_or_zero "$($PY psmcplus_converged.py $SLURM_ARRAY_TASK_ID $NTASK --remaining 2>/dev/null | tail -1)")
+$PY -u psmcplus_converged.py $SLURM_ARRAY_TASK_ID $NTASK
+RC=$?
+AFTER=$(int_or_zero "$($PY psmcplus_converged.py $SLURM_ARRAY_TASK_ID $NTASK --remaining 2>/dev/null | tail -1)")
+echo "task $SLURM_ARRAY_TASK_ID: rc=$RC remaining $BEFORE -> $AFTER restart=${SLURM_RESTART_COUNT:-0}"
+if [ "$RC" -eq 0 ] && [ "$AFTER" -gt 0 ] && [ "$AFTER" -lt "$BEFORE" ] && [ "${SLURM_RESTART_COUNT:-0}" -lt 8 ]; then
+  scontrol requeue "$SLURM_JOB_ID"
+fi
+exit $RC

additional/psmcplus_converged/dropin/chain0_level32.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b44482f739e0da4fc46c702eb22b0c97fccb80325d555f50748222ccbddb63a
+size 107621430

additional/psmcplus_converged/meanfill/chain0_level32.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef67fb185db3cc72133d9a88503c14b29ad4ce942bdda7c792c57297db6f64aa
+size 107621430

additional/psmcplus_converged/meanfill_baseline/chain0_level32.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1aa9f6b66ce60f682509d0ebed70c82112b8a5f0d1d6d9cc979dbdce5faa36e9
+size 107621430

additional/psmcplus_converged/patch.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a469373454b7102b71d5bc9fa221d3be3ad8189036c4aa9687db6a21b7d409f
+size 36898552

additional/psmcplus_converged/pilot_rows_12500.json

@@ -0,0 +1,25 @@
+{
+ "candidate_pool_rows": 89996,
+ "candidate_pool_sha256": "d571bd350f9fc0c7ddf91a02a29b9705c99b2ce7272c7c3545c40485e54843d7",
+ "pilot_evaluation_rows": 500,
+ "pilot_evaluation_sha256": "89b266b21d80790ee1cd0e65315a9e567949e4df3c42eb94aa038e2b311b7c2f",
+ "pilot_fit_rows": 12500,
+ "pilot_fit_sha256": "c22183c23581f840ebcd0f5f5098c6f707e1a46419a14776183cf7700e4c7e13",
+ "pilot_inner_rows": 500,
+ "pilot_inner_sha256": "efb80b6c6bb63a378f1645e9c8cd2a296b65f3a97bd9e753744fb3df749a9699",
+ "plan": "$WORK/compshare_archive_20260916/files/runs/fixed32_fit89996_inner500_eval500_d128_e12_seed20260728/PLAN.json",
+ "registry_dir": "$WORK/registry109k",
+ "registry_rows": 104996,
+ "roots": [
+  "$DATA/DLCoalSim/prod_30mb_110k_128hap_20260824"
+ ],
+ "union_rows": 13500,
+ "union_sha256": "05eea0a41793a0bc92d7a181ceb793272276d1b7c099b9dafa338f0b74a790c8",
+ "variant_count": {
+  "max": 12309022,
+  "mean": 458194.39762962965,
+  "median": 84318.0,
+  "min": 667,
+  "sum": 6185624368
+ }
+}

additional/psmcplus_converged/pilot_rows_12500.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:936c345a349f5696e836e8bc9e5fce08159207d9eedf5c1dc96e34cc2d8d0e57
+size 1312046

additional/psmcplus_converged/psmcplus_converged.py

@@ -0,0 +1,459 @@
+"""Converged-PSMC+ sidecar variant: the stored refit, iterated, for chain 0 / level 32 only.
+
+The stored production sidecar (sidecar109k/chain0_level32.npz) is
+
+    [  0: 64] pooled mean over the level's scored diploids of the PLAIN decode (lambda = 1)
+    [ 64:128] population SD of that decode
+    [128:192] pooled mean after ONE prior refit  (lambda_b = N0 / Ne_b of the plain pooled curve)
+    [192:256] population SD of that refit
+
+i.e. iterates 1 and 2 of a fixed-point iteration that has not converged.  This driver runs the
+SAME iteration for K iterates and writes iterate K into the second half, leaving the first half
+(the plain decode) untouched, so a training ablation against the stored file changes exactly one
+thing: how far the refit was iterated.
+
+Everything that touches PSMC+ is copied VERBATIM from the production builder
+$DATA/DLCoalSim/psmcplus_ladder.py (install_grid, map_slices, segments, write_bed,
+binned_map, seq_parts, make_seq_info, make_shared, decode, the mhs construction, the level-local
+theta / N / rho / BIN, the (1.0, 9.5) units guard) and occ_to_ne comes from psmc_exact.py's head
+through the same exec-the-head trick, so iterate 1 and iterate 2 reproduce the stored columns.
+
+Two modes:
+  cold  (PSMC_WARM_START=0, default)  all K iterates decoded here; iterates 1 and 2 are compared
+        against the stored file per row and the max abs difference is recorded.
+  warm  (PSMC_WARM_START=1)           iterates 1 and 2 are READ from the stored file (float32) and
+        only iterates 3..K are decoded.  Saves 2 of K decode passes.  The only difference from cold
+        is that lambda for iterate 3 is built from the float32 stored pooled mean instead of the
+        float64 one; the induced relative change in lambda is ~1e-7.
+
+Never opens a sealed selection row: the row list is built by select_pilot_rows.py from the
+registry, which excludes all 4,248 sealed rows, and every sample_id is re-checked against the
+cohort split here before any fragment is touched.
+
+Usage:  python psmcplus_converged.py TASK NTASK
+Env:    PSMC_ROWS_NPZ (row list), PSMC_OUT, PSMC_ITERATES (default 6), PSMC_WARM_START,
+        PSMC_BUDGET_S, PSMC_MAX_ROWS, PSMC_STORED (stored sidecar npz), PSMC_TIME_ONLY
+"""
+import sys, os, glob, time, tempfile, io, contextlib, json
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, '$DATA/DLCoalSim/PSMCplus')
+sys.path.insert(0, '$DATA/DLCoalSim/train-deploy-20260826-carrier-raw-v76-tap-label')
+sys.path.insert(0, '$DATA/DLCoalSim/ladder')
+sys.path.insert(0, '$WORK/src_20260903')
+
+task, ntask = int(sys.argv[1]), int(sys.argv[2])
+# occ_to_ne (and the dt it closes over) come from psmc_exact.py's head, verbatim, as in psmcplus_ladder.py
+_src = open('$DATA/DLCoalSim/psmc_exact.py').read(); _head = _src.split('rows_done = 0')[0]
+_argv = sys.argv; sys.argv = ['x', '0', '1', '1', '/tmp']; exec(compile(_head, 'psmc_exact_head', 'exec')); sys.argv = _argv
+task, ntask = int(_argv[1]), int(_argv[2])
+from simulator.utils import time_grid
+from simulator.config import Config
+edges_gen, _ = time_grid(Config()); edges_gen = np.asarray(edges_gen, float); NB = len(edges_gen) - 1
+assert NB == 64, ('expected 64 bins, got', NB)
+assert edges_gen[0] > 0 and np.all(np.diff(edges_gen) > 0), 'edges must be positive and increasing'
+DP = NB + 1
+
+from ladder_spec import chain_columns
+os.environ.setdefault('PSMCPLUS_ROOT', '$DATA/DLCoalSim/PSMCplus')
+import importlib.util as _ilu
+_spec = _ilu.spec_from_file_location(
+    'dlcoal_psmcplus_sidecar',
+    '$WORK/src_20260903/training/psmcplus_sidecar.py')
+_side = _ilu.module_from_spec(_spec)
+sys.modules[_spec.name] = _side
+_spec.loader.exec_module(_side)
+Emissions, _FORWARD, _BACKWARD = _side.Emissions, _side._FORWARD, _side._BACKWARD
+
+import transition_matrix as TM, utils as U, BaumWelch as BWmod
+from utils import (get_het_mask_indices, get_binned_data, get_B_sequence, write_emission_probs,
+                   write_emission_masked_probs, write_Q_array_withR)
+from BaumWelch import BaumWelch
+
+CHAIN, LEVEL, FEAT = 0, 32, 256
+GUARD_LO, GUARD_HI = 1.0, 9.5
+N_HAP, N_DIP = 128, 64
+FRAG_DIR = '$DATA/DLCoalSim/prod_30mb_110k_128hap_20260824/samples/.fragments'
+ROWS_NPZ = os.environ['PSMC_ROWS_NPZ']
+STORED = os.environ.get('PSMC_STORED', '$WORK/sidecar109k/chain0_level32.npz')
+ITERATES = int(os.environ.get('PSMC_ITERATES', '6'))
+WARM = os.environ.get('PSMC_WARM_START', '0') == '1'
+TIME_ONLY = os.environ.get('PSMC_TIME_ONLY', '0') == '1'
+OUT = os.environ.get('PSMC_OUT', '$WORK/sidecar109k_converged_20260916/shards')
+os.makedirs(OUT, exist_ok=True)
+SHARD = '%s/shard_%05d.npz' % (OUT, task)
+assert ITERATES >= 2
+
+
+def install_grid(edges_coal):
+    e = np.concatenate([[0.0], np.asarray(edges_coal, float)])
+    def ti(D, spread_1, spread_2, final_T_factor=None): return e.copy()
+    TM.time_intervals = ti; U.time_intervals = ti; BWmod.time_intervals = ti
+    return e
+
+
+def map_slices(z, k):
+    if 'obs_mut_pos_offsets' in z.files:
+        mpo, mro = z['obs_mut_pos_offsets'], z['obs_mut_rate_offsets']; rpo, rro = z['obs_rec_pos_offsets'], z['obs_rec_rate_offsets']
+        mp = z['obs_mut_pos'][int(mpo[k]):int(mpo[k+1])]; mrt = z['obs_mut_rate'][int(mro[k]):int(mro[k+1])]
+        rp = z['obs_rec_pos'][int(rpo[k]):int(rpo[k+1])]; rrt = z['obs_rec_rate'][int(rro[k]):int(rro[k+1])]
+    else:
+        mo, ro = z['obs_mut_offsets'], z['obs_rec_offsets']
+        mp = z['obs_mut_pos'][int(mo[k]):int(mo[k+1])]; mrt = z['obs_mut_rate'][int(mo[k])-k:int(mo[k+1])-(k+1)]
+        rp = z['obs_rec_pos'][int(ro[k]):int(ro[k+1])]; rrt = z['obs_rec_rate'][int(ro[k])-k:int(ro[k+1])-(k+1)]
+    return mp, mrt, rp, rrt
+
+
+def segments(pos, rate, L):
+    pos = np.asarray(pos, float); rate = np.asarray(rate, float); assert len(pos) == len(rate) + 1
+    starts = pos[:-1].copy(); ends = pos[1:].copy(); r = rate.copy()
+    if starts[0] > 0: starts = np.concatenate([[0.0], starts]); ends = np.concatenate([[starts[1]], ends]); r = np.concatenate([[r[0]], r])
+    keep = starts < L; starts, ends, r = starts[keep], np.minimum(ends[keep], L), r[keep]
+    if ends[-1] < L: starts = np.concatenate([starts, [ends[-1]]]); ends = np.concatenate([ends, [L]]); r = np.concatenate([r, [r[-1]]])
+    e = np.rint(ends).astype(np.int64); e[-1] = int(L); s = np.concatenate([[0], e[:-1]])
+    ok = e > s; s, e, r = s[ok], e[ok], r[ok]
+    mean = float((r * (e - s)).sum() / (e - s).sum())
+    return s, e, r, mean
+
+
+def write_bed(path, s, e, rel, fmt, chrom='1'):
+    with open(path, 'w') as f:
+        for a, b, v in zip(s, e, rel): f.write(('%s\t%d\t%d\t' + fmt + '\n') % (chrom, a, b, v))
+
+
+def binned_map(bed, L, is_rec, BIN):
+    B = get_B_sequence(bed, int(L), BIN, ztype='R' if is_rec else 'B')
+    Bb = B[:len(B) - len(B) % BIN].reshape(-1, BIN).mean(1)
+    if is_rec: Bb = np.floor(Bb * 100) / 100.0; Bb[Bb == 0] = 1e-5
+    vals = np.unique(Bb); idx = np.searchsorted(vals, Bb).astype(int)
+    return idx, vals
+
+
+def seq_parts(mhs, BIN):
+    hets_sequence, masks_sequence, seq_length, hets, masks = get_het_mask_indices(mhs, BIN)
+    het_data = get_binned_data(hets, BIN); mask_data = get_binned_data(masks, BIN)
+    j_max = int(np.max(het_data[1, :]))
+    return (het_data, mask_data, j_max, int(seq_length), len(hets), len(masks))
+
+
+def make_seq_info(parts, Bidx, Bvals, Ridx, Rvals, BIN):
+    het_data, mask_data, j_max, seq_length, n_hets, n_masks = parts
+    nb = int(seq_length / BIN)
+    bi = Bidx[:nb]; ri = Ridx[:nb]
+    if len(bi) < nb: bi = np.concatenate([bi, np.full(nb - len(bi), bi[-1] if len(bi) else 0)])
+    if len(ri) < nb: ri = np.concatenate([ri, np.full(nb - len(ri), ri[-1] if len(ri) else 0)])
+    return [het_data, mask_data, j_max, seq_length, n_hets, n_masks, bi, Bvals.copy(), ri, Rvals.copy()]
+
+
+def make_shared(theta, rho, edges_full, lam, Rvals, BIN, j_max):
+    E = write_emission_probs(DP, BIN, theta, j_max, edges_full, midpoint_end=True)
+    Em = write_emission_masked_probs(DP, BIN, theta, j_max, edges_full, midpoint_end=True)
+    lam_vals = np.ones(DP) if lam is None else np.clip(np.asarray(lam, float), 0.05, 50.0)
+    assert lam_vals.shape == (DP,)
+    buf = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(buf):
+            bw = BaumWelch(sequences_info=[None], D=DP, E=E, E_masked=Em, lambda_A_values=lam_vals,
+                           lambda_B_values=None, gamma_fg=None, lambda_A_segs=[[DP, 1]], lambda_B_segs=None,
+                           rho=rho * BIN, theta=theta, T_S=None, T_E=None, T_array=edges_full,
+                           bin_size=BIN, j_max=j_max, cores=1, estimate_rho=False,
+                           midpoint_end=True, output_path=None)
+            tm = TM.Transition_Matrix(D=DP, midpoint_transitions=False)
+            tm.write_tm(lambda_A=bw.lambda_A_current, lambda_B=None, T_S_index=None, T_E_index=None,
+                        gamma=None, check=False, rho=bw.rho, exponential=True)
+            Qarr = np.ascontiguousarray(
+                write_Q_array_withR(tm.Q, np.asarray(Rvals, float), bw.rho, DP, 0.1, 50,
+                                    bw.lambda_A_current, False))
+    except BaseException as e:
+        raise RuntimeError('PSMC+ setup failed: %r | %s' % (e, buf.getvalue().strip()[-300:]))
+    return bw, Qarr
+
+
+def decode(parts, shared, theta, Bidx, Bvals, Ridx, Rvals, BIN):
+    bw, Qarr = shared
+    bw.sequences_info = [make_seq_info(parts, Bidx, Bvals, Ridx, Rvals, BIN)]
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        sequence, Bs, Bv, Rs, Rv = bw.sequence_fcn(0)
+    emissions = Emissions.tabulate(n_states=DP, bin_bp=BIN, theta=theta,
+                                   midpoints=bw.midpoints, map_values=Bv, sequence=sequence)
+    rank = emissions.rank(sequence)
+    Bs = np.asarray(Bs, dtype=np.int64); Rs = np.asarray(Rs, dtype=np.int64)
+    fwd, scales = _FORWARD(emissions.table, Qarr, Bs, Rs, rank, np.ascontiguousarray(bw.init_dist))
+    bwd = _BACKWARD(emissions.table, Qarr, Bs, Rs, rank, np.ascontiguousarray(scales))
+    post = np.maximum(fwd * bwd, 0.0); post = post / np.maximum(post.sum(0, keepdims=True), 1e-300)
+    occ = post.mean(1)[1:]; occ = occ / max(occ.sum(), 1e-300)
+    with np.errstate(divide='ignore', invalid='ignore'):
+        ll = float(np.sum(np.log(scales)))
+    return occ, ll
+
+
+# ------------------------------------------------------------------ rows
+RL = np.load(ROWS_NPZ, allow_pickle=False)
+R_SID = np.asarray(RL['sample_id']).astype(str)
+R_FRAG, R_ROW, R_VC = RL['fragment'].astype(np.int64), RL['row'].astype(np.int64), RL['variant_count'].astype(np.int64)
+R_REG = RL['registry_index'].astype(np.int64)
+NSEL = len(R_SID)
+
+# hard gate: no sealed row may be in this list, checked here and not only upstream
+_split = np.load('$WORK/cohort109k/cohort109k_split.npz', allow_pickle=False)
+_sealed = set(np.asarray(_split['sample_id'])[np.asarray(_split['split_code']) == 2].astype(str).tolist())
+assert not (set(R_SID.tolist()) & _sealed), 'a sealed selection row is in the row list'
+del _split, _sealed
+
+STORE = np.load(STORED, allow_pickle=False)
+STORE_SIDECAR = STORE['sidecar']
+assert STORE_SIDECAR.shape[1] == FEAT
+
+
+def my_rows(task, ntask):
+    """Snake deal over descending variant_count -- the production builder's cost balance."""
+    order = np.argsort(-R_VC, kind='stable')
+    p = np.arange(NSEL)
+    slot = np.where((p // ntask) % 2 == 0, p % ntask, ntask - 1 - (p % ntask))
+    return np.sort(order[slot == task])
+
+
+if len(sys.argv) > 3 and sys.argv[3] == '--remaining':
+    done = set()
+    if os.path.exists(SHARD):
+        try:
+            zz = np.load(SHARD, allow_pickle=False); done = set(zz['registry_index'].tolist())
+        except BaseException:
+            done = set()
+    print(sum(1 for i in my_rows(task, ntask) if int(R_REG[i]) not in done)); sys.exit(0)
+
+
+# ------------------------------------------------------------------ resume
+O_reg, O_sid, O_frag, O_row = [], [], [], []
+O_feat, O_flag, O_meta, O_iter = [], [], [], []
+have = set()
+if os.path.exists(SHARD):
+    try:
+        z0 = np.load(SHARD, allow_pickle=False)
+        O_reg = z0['registry_index'].tolist(); O_sid = z0['sample_id'].astype(str).tolist()
+        O_frag = z0['fragment'].tolist(); O_row = z0['row'].tolist()
+        O_feat = list(z0['features']); O_flag = list(z0['flags'])
+        O_meta = list(z0['meta']); O_iter = list(z0['iterate_means'])
+        have = set(O_reg)
+        print('task %d: resuming with %d rows' % (task, len(O_reg)), flush=True)
+    except BaseException as e:
+        print('task %d: could not resume (%r); starting fresh' % (task, e), flush=True)
+        O_reg, O_sid, O_frag, O_row, O_feat, O_flag, O_meta, O_iter, have = [], [], [], [], [], [], [], [], set()
+
+META_COLS = 12
+
+
+def save():
+    np.savez(SHARD + '.tmp.npz',
+             registry_index=np.array(O_reg, dtype=np.int64),
+             sample_id=np.array(O_sid), fragment=np.array(O_frag, dtype=np.int32),
+             row=np.array(O_row, dtype=np.int8),
+             features=np.array(O_feat, dtype=np.float32).reshape(-1, FEAT),
+             flags=np.array(O_flag, dtype=np.int16).reshape(-1, 2),
+             meta=np.array(O_meta, dtype=np.float64).reshape(-1, META_COLS),
+             iterate_means=np.array(O_iter, dtype=np.float32).reshape(-1, ITERATES, NB),
+             iterates=np.int32(ITERATES), warm_start=np.int32(1 if WARM else 0))
+    os.replace(SHARD + '.tmp.npz', SHARD)
+
+
+_cache = {}
+def frag(p):
+    if p not in _cache: _cache.clear(); _cache[p] = np.load(p, allow_pickle=False)
+    return _cache[p]
+
+
+FR = sorted(glob.glob(FRAG_DIR + '/fragment_*.npz'))
+t0 = time.time()
+tmpdir = tempfile.mkdtemp(prefix='psmcconv_')
+BUDGET = float(os.environ.get('PSMC_BUDGET_S', '1e18'))
+todo = np.array([i for i in my_rows(task, ntask) if int(R_REG[i]) not in have], dtype=np.int64)
+if os.environ.get('PSMC_MAX_ROWS'): todo = todo[:int(os.environ['PSMC_MAX_ROWS'])]
+print('task %d/%d: %d rows to do (%d already done), iterates=%d warm=%d'
+      % (task, ntask, len(todo), len(have), ITERATES, int(WARM)), flush=True)
+
+n_new, row_times = 0, []
+mut_bed = os.path.join(tmpdir, 'mut.bed'); rec_bed = os.path.join(tmpdir, 'rec.bed')
+
+for sel in todo:
+    sel = int(sel)
+    if row_times and time.time() - t0 + 1.25 * max(row_times[-3:]) > BUDGET:
+        print('task %d: stopping before selection row %d, budget %.0fs nearly spent' % (task, sel, BUDGET), flush=True)
+        break
+    row_t0 = time.time()
+    j, k, reg = int(R_FRAG[sel]), int(R_ROW[sel]), int(R_REG[sel])
+    z = frag(FR[j]); sid = str(z['sample_id'][k])
+    assert sid == str(R_SID[sel]), ('row list / fragment sample_id mismatch', sel, j, k, sid, str(R_SID[sel]))
+
+    feats = np.zeros(FEAT, np.float32); flags = np.zeros(2, np.int16)
+    it_means = np.zeros((ITERATES, NB), np.float32)
+
+    vo = z['variant_offsets']; a, b = int(vo[k]), int(vo[k + 1])
+    L = float(z['sequence_length'][k])
+    mp, mrt, rp, rrt = map_slices(z, k)
+    assert len(mp) == len(mrt) + 1 and len(rp) == len(rrt) + 1, (sel, j, k, 'map slice')
+    ms, me, mrate, mu = segments(mp, mrt, L); rs, re_, rrate, r = segments(rp, rrt, L)
+    assert np.isfinite(mu) and mu > 0 and np.isfinite(r) and r > 0, (sel, j, k, 'bad map rates')
+
+    pos = z['variant_positions_bp'][a:b].astype(np.int64)
+    bits = np.unpackbits(np.ascontiguousarray(z['genotype_packed'][a:b]), axis=1, bitorder='little')
+    V = b - a
+    anymiss = np.zeros((V, N_DIP), dtype=bool)
+    mf, mo_ = z['missing_flat_idx'], z['missing_offsets']; mi = mf[int(mo_[k]):int(mo_[k + 1])].astype(np.int64)
+    if len(mi):
+        mvar, mhap = np.divmod(mi, N_HAP); anymiss[mvar, mhap >> 1] = True
+    het = bits[:, 0::2] != bits[:, 1::2]
+    het &= ~anymiss
+    del bits
+    callable_ = L - anymiss.sum(0)
+    het_frac = het.sum(0) / np.maximum(callable_, 1)
+
+    rel_m = mrate / mu; rel_r = rrate / r; n_cold = int((rel_r < 0.02).sum()); rel_r = np.maximum(rel_r, 0.02)
+    write_bed(mut_bed, ms, me, rel_m, '%.3f'); write_bed(rec_bed, rs, re_, rel_r, '%.2f')
+
+    cols = np.asarray(chain_columns(sid, CHAIN)[:LEVEL], dtype=np.int64)
+    th = float(np.mean(het_frac[cols]))
+    assert np.isfinite(th) and th > 0.0, (sel, sid, 'level-32 theta is not positive')
+    BIN = 100 if th * 100.0 <= 1.0 else max(10, int(1.0 / th))
+    N = th / (4.0 * mu); rho = 4.0 * N * r
+    edges_full = install_grid(edges_gen / (2.0 * N))
+
+    mhs_paths = {}
+    for d in cols.tolist():
+        hp = pos[het[:, d]]
+        if len(hp) < 8: continue
+        mpos = pos[anymiss[:, d]]; prev = np.concatenate([[-1], hp[:-1]])
+        nmb = np.searchsorted(mpos, hp, side='right') - np.searchsorted(mpos, prev, side='right')
+        nmb = np.minimum(nmb, np.maximum(hp - prev - 2, 0))
+        called = (hp - prev) - nmb
+        p_ = os.path.join(tmpdir, 'd%02d.mhs' % d)
+        pd.DataFrame({'c': '1', 'p': hp + 1, 'n': called, 'a': 'AT'}).to_csv(p_, sep='\t', header=False, index=False)
+        mhs_paths[d] = p_
+    del het, anymiss, pos
+
+    Bidx, Bvals = binned_map(mut_bed, L, False, BIN); Ridx, Rvals = binned_map(rec_bed, L, True, BIN)
+    parts = {}
+    for d in cols.tolist():
+        if d not in mhs_paths: continue
+        try:
+            parts[d] = seq_parts(mhs_paths[d], BIN)
+        except BaseException as e:
+            parts[d] = None
+            print('row %d d%02d seq_parts failed: %s' % (reg, d, str(e)[:160]), flush=True)
+    usable = [int(d) for d in cols.tolist() if parts.get(d) is not None]
+    assert usable, (sel, sid, 'no usable diploid at chain 0 level 32')
+    j_max_all = max(parts[d][2] for d in usable)
+
+    it_sec = np.zeros(ITERATES); it_scored = np.zeros(ITERATES, dtype=int)
+    lam = None
+    start_it = 0
+    last_good = -1; last_mean = None; last_std = None; last_n = 0
+    if WARM:
+        stored = STORE_SIDECAR[reg]
+        it_means[0] = stored[0:64]; it_means[1] = stored[128:192]
+        feats[0:64] = stored[0:64]; feats[64:128] = stored[64:128]
+        flags[0] = len(usable)
+        log_ne = np.asarray(occ_to_ne(np.asarray(stored[128:192], dtype=np.float64)), float)
+        med = float(np.median(log_ne))
+        assert GUARD_LO < med < GUARD_HI, ('occ_to_ne not log10 diploid Ne', med, sid)
+        lam64 = N / np.power(10.0, log_ne); lam = np.concatenate([[lam64[0]], lam64])
+        start_it = 2
+        last_good, last_mean, last_std, last_n = 1, stored[128:192].astype(np.float64), \
+            stored[192:256].astype(np.float64), len(usable)
+
+    max_repro = -1.0
+    row_failed = False
+    for it in range(start_it, ITERATES):
+        t_it = time.time()
+        try:
+            shared = make_shared(th, rho, edges_full, lam, Rvals, BIN, j_max_all)
+        except BaseException as e:
+            # An extreme lambda can make PSMC+'s transition matrix degenerate.  Iterating stops
+            # here: the row keeps the last iterate that decoded, and the zero rows left in
+            # iterate_means are how the receipt counts what it reached.
+            print('row %d it %d shared setup failed, stopping at iterate %d: %s'
+                  % (reg, it, last_good, str(e)[:400]), flush=True)
+            break
+        per = np.full((len(cols), NB), np.nan)
+        for s, d in enumerate(cols.tolist()):
+            if parts.get(d) is None: continue
+            try:
+                occ, _ = decode(parts[d], shared, th, Bidx, Bvals, Ridx, Rvals, BIN)
+                if np.isfinite(occ).all(): per[s] = occ
+            except BaseException as e:
+                print('row %d it %d d%02d decode failed (Q %s, E %s): %s'
+                      % (reg, it, d, getattr(shared[1], 'dtype', '?'),
+                         getattr(getattr(shared[0], 'E', None), 'dtype', '?'), str(e)[:400]), flush=True)
+        keep = np.isfinite(per).all(1)
+        if not keep.any():
+            # Never fatal to the task: one unscorable row must not cost the other ~70 it holds.
+            print('row %d it %d scored no diploid, stopping at iterate %d' % (reg, it, last_good), flush=True)
+            if it == 0:
+                print('row %d: PLAIN PASS FAILED, row skipped entirely' % reg, flush=True)
+                row_failed = True
+            break
+        pooled = per[keep].mean(0)
+        it_means[it] = pooled
+        it_sec[it] = time.time() - t_it
+        it_scored[it] = int(keep.sum())
+        last_good, last_mean, last_std, last_n = it, pooled, per[keep].std(0), int(keep.sum())
+        if it == 0:
+            feats[0:64] = pooled; feats[64:128] = per[keep].std(0); flags[0] = int(keep.sum())
+        if not WARM and it in (0, 1):
+            # the stored file's own layout: iterate 1 is [0:128], iterate 2 is [128:256]
+            off = 0 if it == 0 else 128
+            mine = np.concatenate([pooled, per[keep].std(0)]).astype(np.float32)
+            d0 = float(np.max(np.abs(mine.astype(np.float64)
+                                     - np.asarray(STORE_SIDECAR[reg][off:off + 128], dtype=np.float64))))
+            max_repro = max(max_repro, d0)
+        log_ne = np.asarray(occ_to_ne(pooled), float)
+        assert log_ne.shape == (NB,)
+        med = float(np.median(log_ne))
+        if it == 0:
+            # the production builder's units guard, in the same place and as strict
+            assert GUARD_LO < med < GUARD_HI, ('occ_to_ne not log10 diploid Ne', med, sid, it)
+        elif not (GUARD_LO < med < GUARD_HI):
+            # later iterates over-disperse by design; lambda is clipped to [0.05, 50] downstream
+            print('row %d it %d: median log10 Ne %.3f outside (%.1f, %.1f)' % (reg, it, med, GUARD_LO, GUARD_HI), flush=True)
+        lam64 = N / np.power(10.0, log_ne); lam = np.concatenate([[lam64[0]], lam64])
+
+    parts.clear()
+    if row_failed:
+        print('row %d: not written; the assembler will report it missing' % reg, flush=True)
+        continue
+    # The refit half is the LAST iterate that decoded.  It is ITERATES-1 on every row that ran to
+    # the end; a row that stopped early carries fewer, and iterate_means' trailing zero rows say so.
+    if last_good >= 1:
+        feats[128:192] = last_mean; feats[192:256] = last_std; flags[1] = last_n
+        if last_good != ITERATES - 1:
+            print('row %d: converged refit is iterate %d of %d' % (reg, last_good + 1, ITERATES), flush=True)
+    else:
+        # Not one refit iterate decoded.  Carry the production refit through and flag it with -1,
+        # so the row is present and complete but never counted as converged.
+        feats[128:256] = STORE_SIDECAR[reg][128:256]; flags[1] = -1
+        print('row %d: NO refit iterate decoded; stored production refit carried through (flag -1)'
+              % reg, flush=True)
+    dt_row = time.time() - row_t0; row_times.append(dt_row)
+    if TIME_ONLY:
+        print(json.dumps({'registry_index': reg, 'sample_id': sid, 'variant_count': int(b - a),
+                          'theta': th, 'BIN': BIN, 'N0': N, 'j_max': j_max_all,
+                          'seconds_total': dt_row, 'seconds_per_iterate': it_sec.tolist(),
+                          'scored': it_scored.tolist(), 'max_repro_diff': max_repro}), flush=True)
+        continue
+    O_reg.append(reg); O_sid.append(sid); O_frag.append(j); O_row.append(k)
+    O_feat.append(feats); O_flag.append(flags); O_iter.append(it_means)
+    O_meta.append([mu, r, float(b - a), L, dt_row, th, float(BIN), N, float(j_max_all),
+                   float(n_cold), max_repro, float(it_sec.sum())])
+    n_new += 1
+    save()
+    if n_new <= 3 or n_new % 5 == 0:
+        print('task %d: reg %d (%s f%d r%d) V=%d theta=%.5f BIN=%d scored=%d/%d repro=%.3g %.0fs | %d rows, %.0fs'
+              % (task, reg, sid, j, k, b - a, th, BIN, int(flags[1]), LEVEL, max_repro, dt_row,
+                 len(O_reg), time.time() - t0), flush=True)
+
+if not TIME_ONLY:
+    save()
+el = time.time() - t0
+print('task %d: %d rows in shard (+%d new), %.0fs, %.1f s/row new'
+      % (task, len(O_reg), n_new, el, el / max(n_new, 1)), flush=True)

additional/psmcplus_converged/select_pilot_rows.py

@@ -0,0 +1,193 @@
+"""Reproduce the runner's --pilot-fit-rows selection for a 12,500-row ablation.
+
+Rule, read from the FROZEN deploy (deploy_20260913_fixed32/training/carrier_raw_runner.py):
+
+    _select_stage_rows(stage="pilot", ...) ->
+        _balanced_quantiles(reverse[fit], rows, args.pilot_fit_rows)
+
+    reverse[fit] are the REGISTRY indices of the architecture-training fit split.
+    _balanced_quantiles groups those candidates by _root_key(row) =
+        row["logical_dataset_root"] or row["physical_dataset_root"],
+    allocates count//n_roots to every sorted root (+1 to the first count%n_roots),
+    orders each root's candidates by (variant_count, canonical_id), takes
+    np.linspace(0, len-1, n_take, dtype=int64) positions, and returns the union
+    SORTED ascending.
+
+    When count == len(candidates) it is a full census: sorted(candidates).
+
+The production run 'fixed32_fit89996_inner500_eval500' was stage=pilot with
+--pilot-fit-rows 89996 == len(fit), i.e. the census branch, so its PLAN.json
+stage_rows["fit"] IS reverse[fit].  That list is the candidate pool here; the
+identity sha in PLAN is re-checked before it is used.
+
+Nothing in this script opens a fragment, and the registry itself already
+excludes the 4,248 sealed selection rows (104,996 = 109,244 - 4,248); the
+sealed sample_ids are loaded only to assert that none of them was selected.
+"""
+import hashlib
+import json
+import sys
+
+import numpy as np
+
+A = "$WORK"
+RUN = f"{A}/compshare_archive_20260916/files/runs/fixed32_fit89996_inner500_eval500_d128_e12_seed20260728"
+REG = f"{A}/registry109k"
+OUT = sys.argv[1] if len(sys.argv) > 1 else f"{A}/bench_h2h_20260915/analysis/final_round/sidecar_variant"
+N_FIT = int(sys.argv[2]) if len(sys.argv) > 2 else 12500
+
+
+def array_sha256(value):                                  # training/data.py::_array_sha256
+    array = np.ascontiguousarray(value)
+    digest = hashlib.sha256()
+    digest.update(array.dtype.str.encode("ascii"))
+    digest.update(json.dumps(array.shape).encode("ascii"))
+    digest.update(memoryview(array).cast("B"))
+    return digest.hexdigest()
+
+
+def root_key(row):                                       # carrier_raw_runner._root_key
+    value = str(row.get("logical_dataset_root") or row.get("physical_dataset_root") or "")
+    if not value:
+        raise ValueError("registry row lacks dataset root")
+    return value
+
+
+def balanced_quantiles(candidates, rows, count):          # carrier_raw_runner._balanced_quantiles
+    values = [int(index) for index in candidates]
+    if count <= 0 or len(values) < count:
+        raise ValueError("not enough candidates for balanced selection")
+    if count == len(values):
+        if len(set(values)) != count:
+            raise ValueError("full split census contains duplicate candidates")
+        return np.asarray(sorted(values), dtype=np.int64)
+    groups = {}
+    for index in values:
+        groups.setdefault(root_key(rows[index]), []).append(index)
+    roots = sorted(groups)
+    allocation = {root: count // len(roots) for root in roots}
+    for root in roots[: count % len(roots)]:
+        allocation[root] += 1
+    selected = []
+    for root in roots:
+        ordered = sorted(
+            groups[root],
+            key=lambda index: (int(rows[index]["variant_count"]), str(rows[index]["canonical_id"])),
+        )
+        n_take = allocation[root]
+        if len(ordered) < n_take:
+            raise ValueError("one logical root cannot satisfy balanced allocation")
+        positions = np.linspace(0, len(ordered) - 1, n_take, dtype=np.int64)
+        selected.extend(ordered[int(position)] for position in positions)
+    if len(selected) != count or len(set(selected)) != count:
+        raise RuntimeError("balanced quantile selection is not exact/unique")
+    return np.asarray(sorted(selected), dtype=np.int64)
+
+
+plan = json.load(open(f"{RUN}/PLAN.json"))
+fit = np.asarray(plan["stage_rows"]["fit"], dtype=np.int64)
+inner = np.asarray(plan["stage_rows"]["inner"], dtype=np.int64)
+evaluation = np.asarray(plan["stage_rows"]["evaluation"], dtype=np.int64)
+ident = plan["stage_rows_identity"]
+for name, arr in (("fit", fit), ("inner", inner), ("evaluation", evaluation)):
+    assert array_sha256(arr) == ident[name]["sha256"], (name, "PLAN stage-row digest mismatch")
+    assert len(arr) == ident[name]["rows"]
+print(f"PLAN stage rows verified: fit {len(fit)}, inner {len(inner)}, eval {len(evaluation)}")
+assert plan["stage"] == "pilot"
+assert len(fit) == len(set(fit.tolist()))
+
+rows = []
+with open(f"{REG}/raw_index.jsonl") as handle:
+    for line in handle:
+        row = json.loads(line)
+        rows.append(
+            {
+                "logical_dataset_root": row.get("logical_dataset_root"),
+                "physical_dataset_root": row.get("physical_dataset_root"),
+                "variant_count": int(row["variant_count"]),
+                "canonical_id": str(row["canonical_id"]),
+                "sample_id": str(row["sample_id"]),
+                "output_index": int(row["output_index"]),
+            }
+        )
+n_rows = len(rows)
+print(f"registry rows {n_rows}")
+assert all(r["output_index"] == i for i, r in enumerate(rows)), "registry order is not output_index order"
+
+# Registry order == level-cache order == sidecar row order:
+# registry sample_identities.jsonl and the cache's are the SAME file digest
+# (PLAN registry_sha256 / cache_sha256 both b91dbfe2...), and the sidecar was
+# assembled in that same cohort order minus the sealed rows.
+assert plan["registry_sha256"]["sample_identities.jsonl"] == plan["cache_sha256"]["identities"], (
+    "registry and cache identity manifests differ; the identity map is not the identity"
+)
+
+# fit census branch reproduces PLAN exactly
+census = balanced_quantiles(fit, rows, len(fit))
+assert array_sha256(census) == ident["fit"]["sha256"], "census branch does not reproduce PLAN fit rows"
+
+pilot_fit = balanced_quantiles(fit, rows, N_FIT)
+print(f"pilot fit rows ({N_FIT}) sha256 {array_sha256(pilot_fit)}")
+
+# rows the ablation also needs values for: the pilot inner/eval sets, already
+# balanced-quantile subsampled at 500 each in the production run.
+union = np.unique(np.concatenate([pilot_fit, inner, evaluation]))
+print(f"union fit+inner+eval = {len(union)} rows (overlap {len(pilot_fit) + len(inner) + len(evaluation) - len(union)})")
+
+split = np.load(f"{A}/cohort109k/cohort109k_split.npz", allow_pickle=False)
+sealed = set(np.asarray(split["sample_id"])[np.asarray(split["split_code"]) == 2].tolist())
+print(f"sealed sample_ids: {len(sealed)}")
+sel_sid = [rows[int(i)]["sample_id"] for i in union]
+assert not (set(sel_sid) & sealed), "a sealed row entered the selection"
+assert not (set(r["sample_id"] for r in rows) & sealed), "the registry itself contains sealed rows"
+print("no sealed row in the registry or in the selection")
+
+inv = np.load("$DATA/DLCoalSim/prod_inventory_all.npz", allow_pickle=False)
+inv_pos = {str(s): i for i, s in enumerate(inv["sample_id"].tolist())}
+inv_idx = np.asarray([inv_pos[s] for s in sel_sid], dtype=np.int64)
+frag = inv["fragment"][inv_idx].astype(np.int64)
+row_in_frag = inv["row"][inv_idx].astype(np.int64)
+vc = inv["variant_count"][inv_idx].astype(np.int64)
+assert all(str(inv["sample_id"][i]) == s for i, s in zip(inv_idx.tolist(), sel_sid))
+
+kind = np.zeros(len(union), dtype=np.int8)   # bit0 fit, bit1 inner, bit2 eval
+pos = {int(v): i for i, v in enumerate(union.tolist())}
+for arr, bit in ((pilot_fit, 1), (inner, 2), (evaluation, 4)):
+    for v in arr.tolist():
+        kind[pos[int(v)]] |= bit
+
+np.savez(
+    f"{OUT}/pilot_rows_{N_FIT}.npz",
+    registry_index=union,
+    sample_id=np.asarray(sel_sid),
+    inventory_index=inv_idx,
+    fragment=frag,
+    row=row_in_frag,
+    variant_count=vc,
+    kind=kind,
+    pilot_fit=pilot_fit,
+    pilot_inner=inner,
+    pilot_evaluation=evaluation,
+)
+receipt = {
+    "pilot_fit_rows": int(N_FIT),
+    "pilot_fit_sha256": array_sha256(pilot_fit),
+    "pilot_inner_rows": int(len(inner)),
+    "pilot_inner_sha256": array_sha256(inner),
+    "pilot_evaluation_rows": int(len(evaluation)),
+    "pilot_evaluation_sha256": array_sha256(evaluation),
+    "union_rows": int(len(union)),
+    "union_sha256": array_sha256(union),
+    "candidate_pool_rows": int(len(fit)),
+    "candidate_pool_sha256": ident["fit"]["sha256"],
+    "registry_rows": int(n_rows),
+    "registry_dir": REG,
+    "plan": f"{RUN}/PLAN.json",
+    "variant_count": {
+        "min": int(vc.min()), "max": int(vc.max()),
+        "mean": float(vc.mean()), "median": float(np.median(vc)), "sum": int(vc.sum()),
+    },
+    "roots": sorted({root_key(rows[int(i)]) for i in union}),
+}
+json.dump(receipt, open(f"{OUT}/pilot_rows_{N_FIT}.json", "w"), indent=1, sort_keys=True)
+print(json.dumps(receipt, indent=1, sort_keys=True))

additional/psmcplus_converged/shards/shard_00000.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:175783a8efd90931367f45309f776da3f2b273ae0ec4d64e462393a830856651
+size 184821

additional/psmcplus_converged/shards/shard_00001.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:678a8c6e0cd1dac22818647f421a7907fb25facdd741d167cca2e0e305a3de19
+size 184821

additional/psmcplus_converged/shards/shard_00002.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07415e026ac145fa9848bea01becb0003fbd362c389e50c4b2334b41625d0d54
+size 184821

additional/psmcplus_converged/shards/shard_00003.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52dff0d85cf58d549f1654a246af421ebfe1aae14c4ab6c427f761561045069a
+size 184821

additional/psmcplus_converged/shards/shard_00004.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ad6ebd873f75ef271b734978bf9d6cbf147160c65937e9f3360e1b4dd2b0066
+size 184821

additional/psmcplus_converged/shards/shard_00005.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2793118f8c0ae31dc690d94afb8e4ef2e94a2950a1678d179d375d19360e731f
+size 184821

additional/psmcplus_converged/shards/shard_00006.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73263856ab89af57aed1c1e2cb307274b255aca5903b2799b7d39a2ea9517828
+size 184821

additional/psmcplus_converged/shards/shard_00007.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:786b1c07556e36299137cf231a9cd25d331afdd9eb5db6f415f58f8aad284fa3
+size 184821

additional/psmcplus_converged/shards/shard_00008.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa4eab05bdd6a96e7fec6abe65dd6d9d7dd614c0cb54559fb2a55a105f0941fd
+size 184821

additional/psmcplus_converged/shards/shard_00009.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d32bf2ab69c79099f4df480141de2b68756880883500d4f996ac54bd5d7b1250
+size 184821

additional/psmcplus_converged/shards/shard_00010.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb05ca7d7ba691ed33fd2ed5e676e693f2e1822389b17f8650b899c4e8d69b9f
+size 184821

additional/psmcplus_converged/shards/shard_00011.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a900bafeb58b2521748e127e9428f01bd5b298d815d97c3ff84fed92e529e34
+size 184821

additional/psmcplus_converged/shards/shard_00012.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f97fc3694c052cd32c52654f8dab09e30b406199f8fe520a5edd73673dd95dd4
+size 184821

additional/psmcplus_converged/shards/shard_00013.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ff68248d333594f28db2b7868cf65d8239d483971107b3e71a7694c05cc93cb
+size 184821

additional/psmcplus_converged/shards/shard_00014.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2daf719bf1286a33067ef350b10caded42a5e12afbadda00984c01375aeddbcb
+size 184821

additional/psmcplus_converged/shards/shard_00015.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db9ec5136280354918bad1928fba286a4b4a306f1b5c94c0380e3959859c188a
+size 184821

additional/psmcplus_converged/shards/shard_00016.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb4a7b3defd7ee55d7cb04268325955af787628f141779ded3906603ab4b4940
+size 184821

additional/psmcplus_converged/shards/shard_00017.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3458694ad498b4d126dd79866968176986cee680ba51151fe5ec74ef2dd016dd
+size 184821

additional/psmcplus_converged/shards/shard_00018.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:672abdbafdb39c3fc8f499d7cefc9052ede8f297c057d1c51cf6a65ce1ec2982
+size 184821

additional/psmcplus_converged/shards/shard_00019.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:685a9cf4f8c5e8675838cebde74b67470877bfce3ecc1fb3877e115f54e59edf
+size 184821

additional/psmcplus_converged/shards/shard_00020.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a3bce717bd0d54ca23786cc03eb5c6b6ec56901525cc368032fb871da3a5a7b
+size 184821

additional/psmcplus_converged/shards/shard_00021.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:404cd7b5e5e6b72ba54fbaa9c037ea2c081c67cc8241666ef83de5b5e2ced770
+size 184821

additional/psmcplus_converged/shards/shard_00022.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:febd7dc6b540753b456ad2c910396f28d5f2cc394e3698ec10f201d09f6fb9d5
+size 184821

additional/psmcplus_converged/shards/shard_00023.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c7be5a49b708b5d27a71334b4b7f18c7981a336b0005314c85446615f9c1263
+size 184821

additional/psmcplus_converged/shards/shard_00024.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16d9df2af97aa56e963d9a50c95c1dd00596e9219db1b5a349d58cda960d7c8e
+size 184821

additional/psmcplus_converged/shards/shard_00025.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d45b36f57abab27a5a96b0f113e2b9d44edb4111a9ed5af0721262d4ee876f8
+size 184821

additional/psmcplus_converged/shards/shard_00026.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02f84aa1553533bbba280fd7d3f4be5f2b496de7c159cf3fba731e151090f392
+size 184821

additional/psmcplus_converged/shards/shard_00027.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:247626952195e61d1f5371ea76097a4713f0b3a1dbccd4e99e56d943b0ad826f
+size 184821

additional/psmcplus_converged/shards/shard_00028.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c12a928c830199be65caa1e0c48657ea148a341915f492e2dd31780b7e6417a
+size 184821

additional/psmcplus_converged/shards/shard_00029.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e65ac17f3c361d309b2b6665a7ef76778c9141fabf0bc9d5ecb27f0c0ad6f53a
+size 184821

additional/psmcplus_converged/shards/shard_00030.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bdf1723f8ce0b039e236ed5908077159a30efbd41c50cd0acf6a858069f82ab
+size 184821

additional/psmcplus_converged/shards/shard_00031.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f0019112740515346de29c8f1638ad5eaff2fcf73b24f81dc7d68899bfdc533
+size 184821

additional/psmcplus_converged/shards/shard_00032.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38cee36da5d99a80a99a6589ca1ea1b6c2d1510aa4bc60417aa93cc635794d27
+size 184821

additional/psmcplus_converged/shards/shard_00033.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c48c3be002de381da87a63c2d9a9fe34afd9ca30f1dd81e5116984319555ff0b
+size 184821