Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/README.md

@@ -0,0 +1,432 @@
+# scSemiProfiler as a paired few-pair baseline (`scsemi5`)
+
+Set up 2026-09-28. This is scSemiProfiler run in its own design: single cells for a few representatives, bulk for everyone. It is scored head-to-head with our LoRA-5 arm on the same draws.
+
+- **Representatives:** the 5 training donors of each few-pair draw (`data/<ds>/fewshot_n5/draw<j>/train_donors.txt`). Every usable row of those donors is used, with its real single cells and its real bulk.
+- **Targets:** the draw's `test_samples.txt` rows, from their real bulk only.
+
+The frozen ImMicro campaign (`plans/immicro_scsemi_comparison_20260927/`) is not modified. Its pinned vendor code, compatibility patch, gene-set translation and `runtime_env` are reused.
+
+## What upstream does with real bulk (`bulktype`)
+
+Source: `vendor/scSemiProfiler/scSemiProfiler/inference.py::fast_semi`, `initial_setup.py`, `singlecell_process.py`, `representative_selection.py`. The upstream commit is `c2aea02`.
+
+**Bulk preprocessing (`initsetup`).** Bulk is library-normalised to 10^4 (`normed=False`), then `log1p`. It is PCA-reduced to `min(100, n_samples-1)` components; the PCA is fitted on all samples, representatives and targets. This matrix is the only bulk the method uses afterwards.
+
+**Representative single cells (`scprocess`).**
+- Each cell is library-normalised to 10^4.
+- Background removal zeroes every value ≤ 10 (1e-3 of the library).
+- Gene-set scores are computed from c2.cp and the variable ones are kept (`hvset`).
+- A k=15 cell graph is built and neighbor-smoothed features are added.
+
+**Pretraining per representative.**
+- Pretrain 1 reconstructs the representative's cells: VAE 100 epochs, then GAN 100×3.
+- Pretrain 2 adds a bulk loss whose target is the representative's own pseudobulk, i.e. the mean of its processed cells: VAE 50, GAN 50×3.
+- The representative's real bulk is not used in pretraining.
+
+**`bulktype='real'` (used here).** The target's bulk-loss vector is
+
+`pseudobulk_rep × (bulk_tgt + 0.1) / (bulk_rep + 0.1)`
+
+- Both bulks are real CP10K (`expm1` of the processed bulk).
+- The ratio is 1 on the gene-set features.
+- So the real bulk enters only as a gene-wise fold change between the target and its own representative. That cancels the bulk→sc platform bias, and the absolute scale comes from the representative's single cells.
+
+**`bulktype='pseudobulk'` (frozen ImMicro campaign).** The target's CP10K bulk replaces the gene part of that vector directly. This is meant for inputs that are already in pseudobulk space.
+
+**Inference.**
+- 5 ministages × 150 epochs.
+- The bulk weight rises 8 → 1024 across ministages, with a shrinking upper-bound mask.
+- The encoder input is the representative's cells, so the method outputs one generated cell per representative cell. Composition is inherited from the representative except where cells shift state.
+- Output = ZINB mean, rescaled to each representative cell's library. Values ≤ 10 are zeroed, which leaves about 2 % non-zero in the frozen run.
+
+**Assignment.** Each target uses exactly one representative. Upstream's rule is `representative_selection.update_membership`: nearest representative by Euclidean distance in the bulk PCA above. The fixed representatives replace upstream's KMeans / active-learning choice. `assignment.json` records every distance.
+
+## Protocol (per split)
+
+| item | setting |
+|---|---|
+| upstream | commit `c2aea021…`, frozen compatibility patch; vendor file hashes checked at every call |
+| inputs | raw bulk counts and raw UMI counts on the modeled genes (`normed=False`, `logged=False`) |
+| modeled genes | 6k panel genes with `bulk_valid` in every representative and target row and `sc_valid` in every representative row (no target sc mask) |
+| `initsetup` | `geneselection=False`, `batch=1` (its KMeans output is overwritten) |
+| representatives | every usable row of the 5 training donors (Ji 7–9, Giroux 12–14, Imperial 12–15, sepsis and ImMicro 5 rows per draw) |
+| `scprocess` | `cellfilter=False`, `threshold=1e-3`, `geneset=True`, `k=15` |
+| gene sets | pinned c2.cp v7.4 translated to panel Ensembl IDs with the frozen campaign's own `translate_gmt()`; restricted to the frozen 5,913-gene axis, all 2,922 pathways are identical to the frozen mapped GMT (`genesets/geneset_assets.json`) |
+| budget | upstream defaults: pretrain 1 = VAE100/GAN100 (lr 1e-3); pretrain 2 = VAE50/GAN50 (lr 1e-4); inference = 150 epochs × 5 ministages (lr 2e-4), `bulktype='real'`, `pseudocount=0.1` |
+| seeds | base 20260927; pretrain 1 = base+1000+row, pretrain 2 = base+2000+row, target = base+row (row = index in the bulk file) |
+
+## Modeled genes
+
+The count equals the scorer's scoring genes in every dataset. The masks do not vary within a dataset's usable rows, so the count is the same in all 5 draws.
+
+| dataset | modeled genes |
+|---|---:|
+| ImMicro | 5,508 |
+| Ye 2026 sepsis | 5,975 |
+| Ji 2025 ChILI | 5,752 |
+| Giroux 2022 | 5,563 |
+| Imperial ESKD | 5,927 |
+
+Each split's `inputs/inputs_manifest.json` records the count and the equality check.
+
+## Output adapter (`tools/export_npz.py` → `generated/<ds>/fewshot_n5/draw<j>/scsemi5__raw.npz` + `.log`)
+
+**Cells.** 1,500 per target, taken from its representative's n generated cells:
+- n ≥ 1500: drawn without replacement.
+- n < 1500: whole permutations are concatenated to 1,500, so each cell is used ⌊1500/n⌋ or ⌈1500/n⌉ times. This affects representatives with few cells (Imperial down to 265, Ji 759, ImMicro 1,299).
+- The stream is `default_rng([20260927, uint64(sha256(target)[:8])])`. The kept rows are stored in `source_row`.
+
+**Depth.** Each generated cell is rescaled to sum to D.
+- D = the median per-cell UMI, on the modeled genes, of all the representatives' observed cells in the draw.
+- D is a label-free choice from the training pairs; it is recorded in the manifest, the metadata and the receipt.
+- All-zero cells stay zero and are counted.
+- The result is expected counts (Poisson rates); `score_ft.py` reads them out with its fixed Poisson seed.
+
+**Genes.** Modeled genes go at their panel columns; every other panel column is 0.
+
+**`metadata_json`.** `input_condition_path` = the draw's `test_raw.npz`, with its sha. The receipt carries `output_sha256`, per-target runtime and checks.
+
+**Validation.** `tools/validate_export.py` recomputes every row from the lossless shards and checks:
+- the scorer contract (panel gene order, keys, `allow_pickle=False`);
+- finiteness and non-negativity;
+- 1,500 cells per target;
+- the condition samples;
+- the receipt sha.
+
+## Deviations from upstream defaults (all deliberate)
+
+1. **Fixed representatives, no active learning or KMeans.** Both methods must see the same pairs. Assignment uses upstream's own nearest-representative function.
+2. **`geneselection=False`.** The Python API default is the top-6,000 bulk HVGs. The modeled axis is fixed (5.5–6.0k genes) so both methods are scored on the same genes. With fewer than 6,000 genes, HVG selection would keep nearly all of them anyway.
+3. **`cellfilter=False`.** This is the Python API default; the CLI default is on. The benchmark cells are already QC-retained, and upstream's filter needs `MT-` symbols while our axis uses Ensembl IDs.
+4. **Gene-set GMT translated from symbols to Ensembl IDs.** Same translation as the frozen campaign.
+5. **Frozen compatibility patch.** Three changes: an unused `scvi.nn` import is removed; `use_gpu` is translated to `accelerator`; the `geneset_len=0` slice is fixed (inactive here).
+5b. **Compatibility addition 2026-09-28 (`trailing_size1_batch_20260928`).** When a representative's cell count n satisfies n % 128 == 1, the last pretraining minibatch holds one cell and the encoder's BatchNorm1d crashes (seen in Ji draw 0 at N150_BC, 2,433 cells, and Imperial draw 0 at C141_0202, 1,025 cells).
+   - In `vaegan.train()` the scvi `DataSplitter` now gets its supported `drop_last=True` option in that case only. That is the remedy upstream itself left commented out in the same function (a drop-last splitter when `n_obs % batch_size == 1`).
+   - Every other cell count takes the byte-identical original call. No cell is removed from the data: each epoch reshuffles all n cells and skips the single leftover one.
+   - Tool: `tools/compat_patch_20260928.py`. It updates `vendor/compatibility.patch` and `vendor/source_manifest.json`, and keeps the previous manifest as `source_manifest.before_20260928.json`.
+   - CPU evidence (`validation/trailing_batch_fix_*.json`): the crash reproduces on the old code; the new code passes pretrain, inference, export and validation for N150_BC; for an unaffected representative, old and new code give bitwise-identical pretrain checkpoints, per-target models and shards.
+   - Scan (`validation/trailing_batch_scan_server{1,2}.json`, all 25 few-pair and 25 CV splits): the few-pair splits hit are Ji 0, 1, 3 (N150_BC), Giroux 0–4 (BAAF62_d7, 7,297 cells) and Imperial 0 (C141_0202). No representative hits the inference condition (n > 9000 and n % 9000 == 1).
+6. **Memory-lean cell graph** (`tools/lean_cellgraph.py`), used in place of upstream `fast_cellgraph` inside `scprocess`.
+   - Upstream's version was OOM-killed at the 16 GiB CPU cap on the largest Giroux representative (15,650 cells). It holds dense n×n copies plus an n×14×G gather and two temporaries of that size, and runs an O(n²) Python loop.
+   - The lean version does the same arithmetic in the same order: it computes the gather in row chunks and vectorises the neighbor lookup, falling back to upstream's loop when a row doesn't have exactly k−1 neighbors.
+   - Its outputs are **bit-identical** to upstream, checked on `selfw`, `adj`, `neighbors`, `neighborx` and the returned tensor (`validation/lean_cellgraph_*.json`, `validation/prepared_*`). It is 5–8× faster.
+   - That rep now prepares at 7.1 GiB peak.
+   - Its sha256 is part of the run signature.
+7. **Engineering only, with no change to the computation.**
+   - The upstream pipeline is run in bounded, resumable chunks: `scinfer`'s loop is re-expressed per representative and per target.
+   - The pretrain-2 checkpoint path is passed to `fast_semi`, which upstream supports.
+   - Each upstream dense output is re-encoded as CSR, verified bit-equal, and the dense `.npy` is deleted (its sha is kept).
+   - `sample_sc/*.h5ad` is deleted after a Giroux draw is exported and validated (its sha is in `prepared.json`).
+8. **Adapter.** 1,500 cells per target and depth D, as above. The normalized output is not called raw counts.
+
+## Validation done (CPU only; CUDA hidden throughout)
+
+- `tests/test_adapter.py`: 6 unit tests pass (row rule, depth rule).
+- **Ji draw 0 smoke** (2 representatives × 400 cells, 4 targets, epochs cut to 1–2; `smoke/ji2025_chili_draw0/`):
+  - inputs → upstream prepare (792 gene-set features) → pretrain and infer in two resumable calls each → export → independent validation (max deviation 1.5e-5) → `score_ft.py`.
+  - The scorer accepted the receipt (`receipt_verified=True`) and ran every metric, including the contrast/DEG path.
+  - The first export revealed that object-dtype `gene_ids` could not be loaded with `allow_pickle=False`. The exporter was fixed, and the failed output is kept under `generated/_failed_object_dtype_20260928/`.
+- **Queue runner, CPU smoke mode** (`SMOKE_CPU=1`; `smoke/queue_test*.txt`): full control flow, chunked loops, export, validation, `clean_sample_sc`, scoring, and skip-on-rerun.
+- **Memory stress and bit-identity of the prepare step:** see "Memory (measured)" below.
+- **Cross-host equivalence.** The same Imperial smoke was run on server_1 (frozen `runtime_env`) and server_2 (new venv). Every artifact is bit-identical: inputs, prepared project, pretrain checkpoints, target shards, exported NPZ and scores. The run signature is the same.
+
+## Code updates on running queues (`compat_migrations.json`)
+
+A work dir's identity is the run signature it was created with, and every receipt is signed with it.
+
+**Migrating a run to new code.** A later code version may continue a run only if:
+- its binding differs from the run's latest binding only in `source` (the vendor manifest) and/or `wrapper_sha256`; and
+- each change is an approved transition listed in `compat_migrations.json`.
+
+The migration is then appended to `run_manifest.json`. New receipts carry `code_signature`, and the export receipt and metadata list the migrations. Any other difference refuses, as before.
+
+**Deploy protocol.** Vendor files are replaced only under an exclusive lock on `.code_update.lock`, and the runner holds a shared lock while it verifies vendor hashes and imports the vendor. The 2026-09-28 deploy went in this order on both hosts:
+1. transitions file;
+2. atomic runner swap;
+3. a ≥120 s wait, so calls started on the old runner are past their vendor import;
+4. the vendor patch under the lock.
+
+Live production dirs migrated cleanly on both hosts, with their identity kept.
+
+## Environments
+
+**server_1.** The frozen `plans/immicro_scsemi_comparison_20260927/runtime_env` is reused unmodified: a venv on `miniforge3/envs/scanvi` plus faiss-cpu, gseapy, igraph, texttable, requests and urllib3. It also takes certifi, charset_normalizer, regex and defusedxml from `~/.local`, as the frozen campaign did. `env_server1.json` has the details.
+
+**server_2.** `scsemi/runtime_env` is built by `tools/prepare_env_server2.sh`. It uses the same base env path and versions, with every one of those packages pinned inside the venv, and runs with `PYTHONNOUSERSITE=1`. `runtime_env/scsemi_environment.json` has the details.
+
+## Launch (coordinating agent only; GPU steps go through `ml-run` after `thermal_guard.sh` + `gpu_usable.sh`)
+
+**server_1** (queue order: ji2025_chili, giroux2022, ye2026_sepsis, immicro; 5 draws each):
+```bash
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+systemd-run --user --unit=scsemi-queue-s1 --setenv=QUEUE=$S/queues/server1_fewshot.txt --setenv=SCORE=1 \
+  /bin/bash $S/tools/run_queue_scsemi.sh
+```
+
+**server_2** (Imperial; its data and outputs live there):
+```bash
+ssh spark-0110 'S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi; \
+  systemd-run --user --unit=scsemi-queue-s2 --setenv=QUEUE=$S/queues/server2_fewshot.txt --setenv=SCORE=1 \
+  /bin/bash $S/tools/run_queue_scsemi.sh'
+```
+
+**Knobs:**
+- `CHUNK_REPS` (2 representatives per GPU call) and `CHUNK_TARGETS` (12 targets per GPU call).
+- `MAX_WAIT_H` (24).
+- `PREP_ONLY=1`: CPU steps only.
+- `PREP_MEM` (16): see the memory note.
+
+**How the queue behaves:**
+- It skips splits that are already exported and validated, and resumes partial splits from their receipts.
+- A failure is logged; the split's outputs are kept with no retry, and the queue moves on.
+- An unreceipted upstream artefact stops that split for inspection.
+- Each split runs under `work/.../.split.lock`, so a `PREP_ONLY` CPU queue and the GPU queue can run at the same time safely.
+
+**Logs and per-target runtime:**
+- `logs/queue_*.log`
+- `work/<ds>/fewshot_n5/draw<j>/{events.jsonl,gpu.log,shards/<target>.json}` (`elapsed_seconds`)
+- the export receipt (`per_target`, `median_target_seconds`)
+
+**Scoring.** With `SCORE=1`, `score_ft.py` runs on the draw's test donors with `contrast_args.sh`, output to `scores/<ds>/fewshot_n5/draw<j>_scsemi5/`. It uses the same donors and reference view as the draw's other arms, so the metrics are directly comparable.
+
+## GPU-time estimate
+
+Basis: the frozen campaign's measured timings on GB10:
+- **Per target:** 37.1 s with 1,500 representative cells, i.e. 750 full-batch steps.
+- **Pretraining:** 80.2 s for 1,500 cells, i.e. 11.1 ms per 128-cell step over 600 epochs.
+
+How they scale:
+- Pretraining scales with representative cells.
+- The per-target range runs from 37 s (overhead-bound) to 37 s × (mean representative cells / 1,500) (data-bound). The inference batch is `min(n, 9000)`.
+
+| dataset (5 draws) | targets | pretrain | targets | total GPU |
+|---|---:|---:|---:|---:|
+| ji2025_chili | 126 | 2.2 h | 1.3–3.3 h | 3.5–5.4 h |
+| giroux2022 | 54 | 10.5 h | 0.6–4.1 h | 11.1–14.6 h |
+| ye2026_sepsis | 385 | 2.6 h | 4.0–19.0 h | 6.6–21.6 h |
+| immicro | 510 | 1.4 h | 5.3–13.0 h | 6.6–14.4 h |
+| **server_1 total** | | | | **28–56 h** |
+| imperial_eskd (server_2) | 715 | 3.0 h | 7.4–14.3 h | 10.4–17.3 h |
+
+The Ji draw 0 receipts (`median_target_seconds`) will place the real per-target cost inside this range.
+
+Load balancing: server_2 can take Giroux or sepsis once `data/<ds>/` and `scoring_cache/<ds>/` are rsynced there.
+
+**As run (draw → host).** server_1 ran `queues/server1_fewshot_d0first.txt`. server_2 ran Imperial 0–4 and then extra queues that took draws off the server_1 tail. Its as-run copies are in `queues/as_run_server2/`; `tools/build_archive_request.py` refreshes them.
+
+| host | draws |
+|---|---|
+| server_1 | Ji 0–4, Giroux 0–4, sepsis 0–3, ImMicro 0, 1, 4 |
+| server_2 | Imperial 0–4, ImMicro 2, 3, sepsis 4 |
+
+- ImMicro 4 started on server_2. At 2026-09-29 23:18 the memory guard stopped it, triggered by another user's vLLM, after 2 of 5 representatives. It was re-queued on server_1 and reruns there from scratch.
+- Sepsis 4 was moved to server_2 on 2026-09-30 at 07:47 (`queues/server2_sepsis_d4_20260930.txt`, unit `scsemi-queue-s2c`) so both hosts finish at about the same time.
+- The inputs match on both hosts: the `cells_panel6k` sha256 and the draw's run signature are identical.
+
+## Disk and memory
+
+### Memory (measured)
+
+Upstream `scprocess`, called once over all representatives, is where memory runs out. It densifies every representative cell, keeps several dense n×n graph copies and an n×14×G gather per representative, and builds a cells×2,922 float64 gene-set matrix.
+
+Measured at the 16 GiB CPU-unit cap:
+- The largest Giroux representative (15,650 cells) was OOM-killed inside `fast_cellgraph`.
+- The full Giroux draw 0 (149k representative cells) was OOM-killed at a 14.0 GiB peak in the cohort gene-set stage.
+- The Imperial draws run with pure upstream code peaked at 8.5–13.4 GiB.
+
+Two changes fix this:
+- the lean cell graph (deviation 6);
+- per-representative orchestration: the cohort `hvset` is computed first with upstream's own steps and order, then upstream `scprocess` runs once per representative.
+
+Both reproduce upstream bit for bit, checked file by file on every prepared file (`validation/`):
+- `prepared_imperial_upstream_vs_final.json`: 5 Imperial draws (70 representatives), final code vs **pure upstream**.
+- `prepared_server1_oneshot_vs_perrep.json`: 15 Ji / sepsis / ImMicro draws, per-representative vs one-shot.
+- `prepared_smoke_ji_upstream_vs_perrep.json`: smoke vs pure upstream.
+- `lean_cellgraph_ji2025_chili_draw0.json`: function-level check on 8 representatives plus a synthetic case.
+
+Peak RSS of the final prepare:
+
+| dataset | peak RSS |
+|---|---:|
+| Ji | 2.9–4.1 GiB |
+| sepsis | 3.8–6.3 GiB |
+| ImMicro | 2.6–2.9 GiB |
+| Imperial | 3.9–5.9 GiB |
+| Giroux draw 0 | 11.6 GiB |
+
+Giroux draws 1–4 have 128–156k representative cells, so a similar peak is expected. `PREP_MEM` (default 16) is the knob if one ever needs more; any value above 16 needs the coordinator's approval.
+
+GPU steps (`ml-run`, `ml.slice`) hold a representative's dense graph a few times in host RAM: at most about 7 GB for the 15.6k-cell representative.
+
+### Disk
+
+**Prepared `scsemi_project/sample_sc/*.h5ad`** (dense n×n graphs):
+
+| dataset | per draw |
+|---|---:|
+| Ji | 3 GB |
+| ImMicro | 2 GB |
+| sepsis | 5 GB |
+| Giroux | 24 GB |
+| Imperial | 4.5 GB |
+
+Every server_1 queue line sets `clean_sample_sc`, so these are deleted once the draw is exported and validated. Their sha256 stays in `prepared.json`, and the files can be re-derived bit-identically.
+
+**Other outputs:**
+- Per-target upstream models: about 20 MB each, so ~22 GB on server_1 and ~14 GB on server_2.
+- Lossless CSR target shards: about 2 % dense.
+- Exported NPZs: compressed.
+
+On 2026-09-28 server_1 had 190 GB free, with 73 GB already used by the 15 pre-prepared draws. Giroux draws 1–4 are prepared lazily by the queue, one at a time.
+
+### Current state (2026-09-28, CPU only; no GPU step has run)
+
+All splits of the few-pair campaign have been CPU-prepared (inputs + upstream prepare) under the final code, except Giroux draws 1–4:
+- server_1: Ji 0–4, sepsis 0–4, ImMicro 0–4, Giroux 0.
+- server_2: Imperial 0–4.
+
+The GPU queues therefore start directly at pretraining; the queue prepares Giroux 1–4 on the way.
+
+server_2 keeps `work/_archive_prelean_20260928/` (pure-upstream reference prepares) and `work/_archive_oneshot_lean_20260928/`. Both are verified duplicates, safe to delete.
+
+## Optional CV variant (`queues/server1_cv.txt`; not started)
+
+Superseded on 2026-10-02 by "5-fold CV (A) and equal pair budget (B)" below: the dense cohort hvset of a CV fold
+does not fit the 16 GiB CPU cap, and the costs below are replaced by measured ones.
+
+- Representatives are every training donor of fold k, including inner-validation donors; targets are fold k's rows.
+- The input builder, wrapper, exporter and queue already support `cv|DATASET|FOLD`.
+- Output: `generated/<ds>/fold<k>/scsemi__raw.npz`.
+
+**Cost.** Pretraining runs once per training row, so it dominates: the targets are only 1/5 of the rows. Same timing basis as above:
+
+| dataset (5 folds) | representatives per fold | pretrain | targets | total GPU | largest prepared fold |
+|---|---:|---:|---:|---:|---:|
+| ji2025_chili | 25–27 | 7.3 h | 0.3–0.9 h | 7.7–8.2 h | 9 GiB |
+| giroux2022 | 18–21 | 14.8 h | 0.2–1.7 h | 15.1–16.6 h | 29 GiB |
+| ye2026_sepsis | 65–66 | 34.5 h | 0.8–4.0 h | 35.4–38.6 h | 53 GiB |
+| immicro | 85–86 | 23.2 h | 1.1–2.7 h | 24.3–25.9 h | 25 GiB |
+| **server_1 total** | | | | **82–89 h** | |
+| imperial_eskd (server_2) | 110–133 | 30.4 h | 1.6–3.6 h | 32–34 h | 39 GiB |
+
+That is about 3× the few-pair campaign. The memory note below applies to every fold, because every large training row becomes a representative.
+
+## 5-fold CV (A) and equal pair budget (B), prepared 2026-10-02 (CPU only; no GPU step run)
+
+- **(A)** `cv|<ds>|<k>`, all five cohorts. Representatives = fold k's training + inner-val rows = exactly the rows
+  `runs/<ds>/fold<k>/real_lora/RUN.json` lists (checked for all 25 folds, Imperial against server_2's RUN.json).
+  Targets = fold k's rows. Output `generated/<ds>/fold<k>/scsemi__raw.npz`.
+- **(B)** `budget|<ds>|<k>|…|<n>`, immicro and ye2026_sepsis, n ∈ {5, 10, 20, 40}. Representatives = `lora_n<n>`'s
+  `train_rows + inner_val_rows` (= `data/<ds>/CAL_BUDGET.json` `fit_sample_ids`; the builder refuses any mismatch).
+  Targets = fold k's rows. Output `generated/<ds>/fold<k>/scsemi_n<n>__raw.npz`, export arm `scsemi_n<n>`.
+
+### Reuse of pretraining: not cohort-wide, only B from A of the same fold
+
+A representative r's pretraining reads `sample_sc/<r>.h5ad`, `geneset_scores/<r>.npy` and `hvset.npy` (vendor
+`setdata`) and is seeded base + 1000/2000 + r's bulk row index; inference reads the same plus the rep / target rows
+of `processed_bulkdata` (per-sample CP10K, independent of other rows), `hvgenes.npy` and r's pretrain-2 model.
+
+- **Gene axis:** the per-split rule gives exactly the cohort-fixed axis (= the scorer's scoring genes) in every CV and
+  budget split of every cohort (`validation/hvset_dependence_20261002.json`). No gene differs.
+- **`geneset_scores/<r>`** depends only on r's cells and the axis: byte-identical for all 35 representatives that
+  occur in more than one few-pair draw.
+- **`hvset`** is scanpy's seurat HVG on the pooled gene-set scores of *all* representatives of the split. It decides
+  which ~700–780 of the 2,922 pathway scores are r's features and enters `feature_var`. Those 35 representatives had a
+  different `sample_sc/<r>` and different pretrain checkpoints in every draw, although their seed index was the same.
+  Across CV folds hvset is never identical (symmetric difference / Jaccard): Ji 35–86 / 0.89–0.95, Giroux 43–66 /
+  0.92–0.95, sepsis 50–121 / 0.85–0.94, ImMicro 7–21 / 0.97–0.99, Imperial 35–77 / 0.90–0.95. A cohort-wide hvset
+  would differ from every fold's by 9–88 pathways and would be selected partly on that fold's test donors' cells.
+- **Seeds:** in A the bulk rows are all usable rows in every fold, so the seed index is fold-independent; a B split's
+  bulk has fewer rows.
+- **GPU determinism:** ImMicro few-pair draw 4, representatives HS19 and HS25, were pretrained independently on server_2
+  (2026-09-29) and server_1 (2026-09-30): all four checkpoints have the same sha256.
+
+So a cohort-fixed pretrain is not equivalent to the per-split protocol (and leaks test-donor cells into feature
+selection); A keeps one pretrain per representative per fold. B can reuse A exactly when it takes A's hvset and seeds:
+`reuse_cv` does that, as a declared protocol variant. B's pathway selection then comes from fold k's whole training
+pool (never a test donor) instead of the n budget rows alone; B-vs-A hvset differences it replaces: sepsis n=5 124–179
+(Jaccard 0.79–0.85) down to n=40 47–99; ImMicro n=5 40–55 (0.93–0.95) down to n=40 8–34. The plain alternative
+(`queues/server1_budget_plain_20261002.txt`: own hvset, own pretraining) costs 77 GPU hours more.
+
+### Code (opt-in; without the new flags / options every tool behaves and signs as before)
+
+- `tools/lean_hvset.py` + `run_scsemi_paired.py --lean-hvset`: the cohort hvset streamed one representative at a time.
+  Bit-identical to `cohort_hvset` (means, variances, hvset bytes) on three draws, and the streamed hvset equals
+  `hvset.npy` of all 25 few-pair draws. Needed because the dense step holds ~70 KiB per representative cell (~34 GiB
+  for a sepsis CV fold).
+- `run_scsemi_paired.py --reuse-from W` (prepare copies W's hvset and refuses unless every representative's
+  `sample_sc` / `geneset_scores` is byte-identical to W's; seeds = W's) and `--phase link` (CPU, hard-links W's
+  receipted checkpoints, receipts name the source). Refused when W's representatives include a target row or donor,
+  or the gene axis, scprocess / pretrain protocol, vendor source, environment, wrapper, cell-graph or gene-set asset differ.
+- `prepare_draw_inputs.py --mode budget --fold k --n N` and `--check-only`; `export_npz.py` arm `scsemi_n<n>`.
+- `run_queue_scsemi.sh`: `budget` lines, options `lean_hvset`, `reuse_cv`, `clean_prepared` (also deletes
+  `geneset_scores/*.npy`, 23 KB per cell), `offload` (`tools/offload_work.sh`: models + `rep_sc.h5ad` to spark-0110 at
+  the same absolute path, sha-verified), `offload|<ds>|cv` lines, env `MIN_FREE_GIB`, `REUSE_ALLOW_PRETRAIN`; smoke
+  lines may name `cv` / `budget`.
+- `tools/check_units.py` (dry run of a queue), `tools/hvset_dependence.py` (the analysis above),
+  `tools/reuse_gpu_check.sh` (one-call GPU confirmation), `../tools/finalize_scsemi_cv_budget.sh` (scoring),
+  `../tools/extra_metrics.py --design scored`.
+- CPU checks: `smoke/queue_test_cv_budget_20261002.txt` (SMOKE_CPU: CV with lean hvset → budget reusing it → link →
+  inference → export → validation, both passed); `validation/reuse_seed_cpu_smoke_20261002.json` (a budget split whose
+  own row index differs, pretrained without link with the CV seeds, gives byte-identical checkpoints);
+  `validation/check_units_*.json` (every unit's builder run, LoRA donor lists, assignment, cost, disk).
+- Edited files are backed up as `*.bak_20261002`. `compat_migrations.json` is unchanged: no earlier work dir needs to
+  continue under the new wrapper (all 25 few-pair draws are exported and validated).
+
+### Queue, time, disk (server_1 only)
+
+`queues/server1_cv_budget_20261002.txt` (65 units + 2 offload lines). Measured cost model (25 few-pair draws):
+pretrain 0.0488 s per representative cell; a target 8.0 s + 0.0188 s per cell of its representative; call overhead
+under 2 %. GPU hours from `validation/check_units_server1_cv_budget_20261002.json`:
+
+| block | units | GPU h | cumulative wall (incl. CPU prepare) |
+|---|---:|---:|---:|
+| A ji2025_chili (canary) | 5 | 7.4 | 8 h |
+| A immicro | 5 | 23.6 | 32 h |
+| B immicro n 5/10/20/40 (reuse) | 20 | 9.2 | 43 h |
+| A ye2026_sepsis | 5 | 35.1 | 80 h |
+| B ye2026_sepsis n 5/10/20/40 (reuse) | 20 | 13.2 | 95 h |
+| A giroux2022 | 5 | 15.3 | 111 h |
+| A imperial_eskd | 5 | 31.0 | 144 h (6.0 d) |
+
+Plain B instead of reuse: 99.7 instead of 22.4 GPU h (≈ 9.3 d in total). `…_userorder.txt` has the same units in the
+order first requested (Ji, Giroux A → sepsis, ImMicro A → B n-major → Imperial A); it finishes at the same time but
+ImMicro's B lands ~2.5 days later.
+
+Disk: the prepared cell graphs + gene-set scores of one split are the transient peak (sepsis CV fold 63 GB, Imperial
+48 GB, sepsis n=40 48 GB) and are deleted after export (`clean_prepared`). Models and inputs stay until offloaded:
+right after export for Ji, Giroux, Imperial and every B split, and for the ImMicro / sepsis CV runs after their B
+lines. Local peak ≈ 85–95 GB (sepsis A); launch with `MIN_FREE_GIB=80` so a prepare waits instead of filling the disk.
+Memory: CPU prepare ≤ 16 GiB (largest representative 15.7k cells, as in the few-pair runs), GPU calls ≤ ~28 GiB host
+RAM (sepsis few-pair maximum); every CPU unit waits for MemAvailable ≥ 32 GiB + its cap.
+
+## Files
+
+- `tools/prepare_draw_inputs.py`: builds the split inputs (bulk.h5ad, rep_sc.h5ad, manifest).
+- `tools/run_scsemi_paired.py`: the upstream wrapper (prepare / pretrain / infer / status).
+- `tools/export_npz.py`: the adapter.
+- `tools/validate_export.py`: independent validation of an exported NPZ.
+- `tools/run_queue_scsemi.sh`: the queue runner.
+- `tools/make_queues.sh`: writes the queue files.
+- `tools/cpu_unit.sh`: CPU systemd unit, ≤ 6 threads, MemoryMax ≤ 16G, 32 GiB floor.
+- `tools/lean_cellgraph.py`: output-identical `fast_cellgraph`.
+- `tools/verify_lean_cellgraph.py`: function-level check of the lean cell graph.
+- `tools/compare_prepared.py`: file-by-file comparison of prepared splits.
+- `tools/compat_patch_20260928.py`: the size-1 trailing batch fix.
+- `tools/scan_trailing_batch.py`: scans every representative for the size-1 batch condition.
+- `tools/compare_runs.py`: bitwise comparison of trained artefacts between two work dirs.
+- `tools/lean_hvset.py`: output-identical, streamed cohort hvset (2026-10-02).
+- `tools/hvset_dependence.py`: gene axis and hvset per CV / budget split, lean-hvset bit-identity (2026-10-02).
+- `tools/check_units.py`: dry run of a queue file (builder, LoRA donor lists, assignment, cost, disk) (2026-10-02).
+- `tools/reuse_gpu_check.sh`: one GPU call confirming a reused pretrain equals a fresh one (2026-10-02).
+- `tools/offload_work.sh`: move a finished split's models + inputs to spark-0110, same absolute paths (2026-10-02).
+- `compat_migrations.json`: approved code transitions.
+- `tools/build_geneset_assets.py`: builds the gene-set asset.
+- `tools/prepare_env_server2.sh`: builds the server_2 environment.
+- `genesets/`: the mapped GMT and its manifest.
+- `vendor/`: a copy of the frozen pinned upstream, hash-verified.
+- `work/`: per-split runs.
+- `smoke/`: CPU smoke runs.
+- `validation/`: bit-identity records.
+- `logs/`: logs.

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/run_scsemi_paired.py

@@ -0,0 +1,672 @@
+#!/usr/bin/env python
+"""Pinned scSemiProfiler in its native paired-representative mode, real bulk, gene sets on (resumable).
+
+Phases (each invocation does a bounded amount of work and exits; receipts make every step skippable):
+  prepare  CPU. upstream initsetup(bulk, normed=False) + fixed representatives + upstream nearest-representative
+           assignment (representative_selection.update_membership on processed_bulkdata.obsm['X_pca']) +
+           upstream scprocess(rep cells, normed=False, threshold 1e-3, geneset=True, k=15).
+  pretrain GPU (via ml-run only).  Per representative: fastrecon (VAE100/GAN100, lr 1e-3) then reconst_pretrain2
+           (VAE50/GAN50, lr 1e-4), exactly the calls upstream scinfer() makes.  --max-reps bounds one call.
+  infer    GPU (via ml-run only).  Per target: fast_semi(rep, target, rep's pretrain-2 model, bulktype='real',
+           pseudocount 0.1, lr 2e-4, 150 epochs x 5 ministages), the call upstream scinfer() makes.
+           The upstream dense output is re-encoded losslessly as CSR (verified equal) with a receipt holding the
+           per-target runtime.  --max-targets bounds one call.
+
+CUDA work belongs to the coordinating agent and must run through ml-run.  No automatic retries.  Partial
+outputs are preserved; an unreceipted upstream artefact stops the run for inspection.
+--smoke (only under scsemi/smoke/, CPU) shrinks the epoch budget to exercise the plumbing.
+
+Opt-in additions 2026-10-02 (without these flags every phase behaves and signs exactly as before):
+  --lean-hvset     prepare computes hvset.npy with tools/lean_hvset.cohort_hvset_lean (one representative in memory;
+                   output-identical to cohort_hvset, validation/hvset_dependence_20261002.json).  Needed for CV folds,
+                   whose dense cohort hvset needs ~70 KiB per representative cell (above the 16 GiB CPU cap).  Recorded
+                   in the run binding, so pass it on every phase of that work dir.
+  --reuse-from W   (equal-budget splits) the split's representatives are a subset of the prepared run W of the same
+                   fold (its CV run).  prepare copies W's hvset.npy instead of selecting one, then runs upstream
+                   scprocess per representative and refuses unless every sample_sc/<r>.h5ad and geneset_scores/<r>.npy
+                   is byte-identical to W's (prepared.json); pretraining seeds are W's (base + 1000/2000 + row index in
+                   W's bulk order).  Phase 'link' (CPU) then hard-links W's receipted pretrain checkpoints with receipts
+                   naming their source; a representative without one is pretrained by phase 'pretrain' with W's seed,
+                   which gives the same bytes (GPU pretraining is bit-reproducible: README "Reuse of pretraining").
+                   Refuses when W's representatives include any of this split's targets.  Recorded in the binding.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import fcntl
+import gc
+import hashlib
+import importlib.metadata
+import json
+import os
+from pathlib import Path
+import re
+import resource
+import shutil
+import sys
+import time
+import types
+
+HERE = Path(__file__).resolve().parents[1]
+SEED = 20260927
+MIGRATIONS = HERE / "compat_migrations.json"          # approved code transitions a run may migrate across
+MIGRATABLE = {"source", "wrapper_sha256"}             # binding components an approved transition may change
+PROTOCOL = {
+    "method": "scSemiProfiler", "setting": "paired_fixed_representatives_realbulk_genesets",
+    "upstream_commit": "c2aea021188759e56ecf14578915c0237aaa75d2",
+    "initsetup": {"logged": False, "normed": False, "geneselection": False, "batch": 1},
+    "scprocess": {"logged": False, "normed": False, "cellfilter": False, "threshold": 0.001, "geneset": True,
+                  "weight": 0.5, "k": 15},
+    "representatives": "fixed: every usable row of the split's training donors (no active learning)",
+    "assignment": "upstream representative_selection.update_membership: nearest representative by Euclidean "
+                  "distance in processed_bulkdata.obsm['X_pca'] (initsetup PCA of log1p CP10K real bulk)",
+    "pretrain1": {"vaesteps": 100, "gansteps": 100, "lr": 1e-3, "k": 15, "diagw": 1},
+    "pretrain2": {"vaesteps": 50, "gansteps": 50, "lr": 1e-4, "k": 15, "diagw": 1.0},
+    "infer": {"bulktype": "real", "pseudocount": 0.1, "lr": 2e-4, "epochs": 150, "ministages": 5, "k": 15,
+              "diagw": 1.0},
+    "seeds": {"base": SEED, "pretrain1": "base + 1000 + bulk row index", "pretrain2": "base + 2000 + bulk row index",
+              "target": "base + bulk row index (frozen campaign rule)"},
+    "output_unit": "normalized_expression (upstream fast_semi output: ZINB mean, rep-cell library, values <= 10 zeroed)",
+    "cellgraph_impl": "tools/lean_cellgraph.fast_cellgraph_lean replaces upstream singlecell_process.fast_cellgraph "
+                      "inside scprocess: same arithmetic, chunked (16 GiB CPU cap); bit-identical outputs verified "
+                      "(validation/lean_cellgraph_*.json)",
+    "scprocess_orchestration": "cohort hvset first (upstream scprocess's own steps: sorted sample_ids, normalize_total "
+                               "1e4, dense, X*(X>10), getGeneSetMatrix score formula, concatenate, log1p, "
+                               "highly_variable_genes) -> hvset.npy; then upstream scprocess once per representative "
+                               "(it skips hvset when hvset.npy exists). Bit-identical to one scprocess call over all "
+                               "representatives (validation/prepared_*.json); peak memory is one representative",
+}
+
+
+def cohort_hvset(project: Path, rep_sc: Path, threshold: float) -> "np.ndarray":
+    """Upstream scprocess's hvset block, run representative by representative (same order, same arithmetic)."""
+    import numpy as np
+    import anndata
+    import scanpy as sc
+    from scSemiProfiler.singlecell_process import getGeneSetMatrix
+    R = anndata.read_h5ad(rep_sc)
+    sids = np.unique(R.obs["sample_ids"])
+    zps = []
+    for sid in sids:
+        a = R[(R.obs["sample_ids"] == sid).to_numpy()].copy()
+        sc.pp.normalize_total(a, target_sum=1e4)
+        X = np.array(a.X.todense())
+        X = X * np.array(X > 1e4 * threshold)
+        genes_upper = [g.upper() for g in list(a.var.index)]
+        gene_set_matrix, _ = getGeneSetMatrix("c2.cp.v7.4.symbols.gmt", genes_upper, "genesets/")
+        zp = X.dot(np.array(gene_set_matrix).T)
+        eps = 1e-6
+        den = (np.array(gene_set_matrix.sum(axis=1)) + eps)
+        zp = (zp + eps) / den
+        zp = zp - eps / den
+        zps.append(zp)
+        del a, X
+    zps = np.concatenate(zps, axis=0)
+    zdata = anndata.AnnData(zps)
+    sc.pp.log1p(zdata)
+    sc.pp.highly_variable_genes(zdata)
+    hvset = zdata.var.highly_variable
+    np.save(str(project) + "/hvset.npy", hvset)
+    return np.asarray(hvset)
+SMOKE_BUDGET = {"pretrain1": {"vaesteps": 1, "gansteps": 1}, "pretrain2": {"vaesteps": 1, "gansteps": 1},
+                "infer": {"epochs": 2}}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(16 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    with tmp.open("w") as stream:
+        json.dump(value, stream, indent=1, default=str)
+        stream.write("\n")
+        stream.flush()
+        os.fsync(stream.fileno())
+    tmp.replace(path)
+
+
+def canonical_sha(value) -> str:
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def resolve_run_identity(run_file: Path, binding: dict, code_signature: str) -> tuple[str, list]:
+    """The run's identity is the signature it was created with (every receipt is signed with it).  A later code
+    version may continue the run only if its binding differs from the run's latest binding in MIGRATABLE components
+    alone and each change is an approved transition in compat_migrations.json; the migration is appended to
+    run_manifest.json.  Anything else refuses, as before."""
+    rec = json.loads(run_file.read_text())
+    identity = rec["run_signature"]
+    migrations = rec.get("migrations", [])
+    if migrations:
+        last, last_sig = migrations[-1]["to_binding"], migrations[-1]["to_code_signature"]
+    else:
+        last, last_sig = {k: rec.get(k) for k in binding}, identity
+        if canonical_sha(last) != identity:
+            raise SystemExit("run_manifest.json binding does not hash to its run_signature; inspect")
+    if last == binding:
+        return identity, migrations
+    changed = sorted(k for k in set(last) | set(binding) if last.get(k) != binding.get(k))
+    if set(changed) - MIGRATABLE:
+        raise SystemExit(f"work dir belongs to different inputs/code/environment ({changed}); use a fresh work dir")
+    approved = json.loads(MIGRATIONS.read_text())["transitions"] if MIGRATIONS.exists() else []
+    used = []
+    for k in changed:
+        frm = canonical_sha(last[k]) if k == "source" else last[k]
+        to = canonical_sha(binding[k]) if k == "source" else binding[k]
+        hit = [x for x in approved if x["component"] == k and x["from"] == frm and x["to"] == to]
+        if not hit:
+            raise SystemExit(f"code change in {k} ({str(frm)[:12]} -> {str(to)[:12]}) is not an approved migration "
+                             f"in {MIGRATIONS.name}; use a fresh work dir")
+        used.append(hit[0]["id"])
+    migrations = migrations + [{"at": datetime.now(timezone.utc).isoformat(), "host": os.uname().nodename,
+                                "from_code_signature": last_sig, "to_code_signature": code_signature,
+                                "changed": changed, "transitions": used, "to_binding": binding}]
+    rec["migrations"] = migrations
+    write_json(run_file, rec)
+    return identity, migrations
+
+
+REUSE_PROTOCOL_KEYS = ("upstream_commit", "scprocess", "pretrain1", "pretrain2", "seeds", "cellgraph_impl",
+                       "scprocess_orchestration")
+REUSE_BINDING_KEYS = ("source", "environment", "wrapper_sha256", "lean_cellgraph_sha256", "geneset_mapped_gmt_sha256")
+
+
+def load_reuse_source(src: Path, work: Path, man: dict, protocol: dict, binding: dict) -> dict:
+    """--reuse-from: the source run W whose hvset and pretraining this split reuses.  Everything a representative's
+    pretraining depends on besides its own cells must be W's: hvset (copied), gene axis, scprocess / pretrain protocol,
+    vendor source, environment, wrapper, cell-graph code, gene-set asset; the seeds are W's.  W's representatives must
+    be a superset of this split's and must not contain any of its targets (W's hvset was selected on W's cells)."""
+    if src == work:
+        raise SystemExit("--reuse-from points at this work dir")
+    for f in ("run_manifest.json", "prepared.json", "inputs/inputs_manifest.json"):
+        if not (src / f).exists():
+            raise SystemExit(f"--reuse-from {src}: {f} missing (prepare the source run first)")
+    srun = json.loads((src / "run_manifest.json").read_text())
+    sprep = json.loads((src / "prepared.json").read_text())
+    sman = json.loads((src / "inputs/inputs_manifest.json").read_text())
+    if sprep["run_signature"] != srun["run_signature"]:
+        raise SystemExit(f"--reuse-from {src}: prepared.json belongs to another run signature")
+    sb = srun["migrations"][-1]["to_binding"] if srun.get("migrations") else srun
+    why = []
+    if sman["dataset"] != man["dataset"] or bool(sman.get("smoke")) != bool(man.get("smoke")):
+        why.append("dataset / smoke flag")
+    if sman["modeled_genes"]["gene_ids"] != man["modeled_genes"]["gene_ids"]:
+        why.append("modeled gene axis")
+    why += [f"protocol.{k}" for k in REUSE_PROTOCOL_KEYS if sb["protocol"].get(k) != protocol.get(k)]
+    why += [k for k in REUSE_BINDING_KEYS if sb.get(k) != binding.get(k)]
+    s_reps = {r["sample_id"] for r in sman["representatives"]}
+    reps = [r["sample_id"] for r in man["representatives"]]
+    if not set(reps) <= s_reps:
+        why.append(f"representatives not in the source run: {sorted(set(reps) - s_reps)[:5]}")
+    if "target_donors" not in man:
+        why.append("inputs manifest has no target_donors (build the split with --mode budget)")
+    else:
+        s_donors = {r["donor_id"] for r in sman["representatives"]}
+        if set(man["targets"]) & s_reps or set(man["target_donors"]) & s_donors:
+            why.append("a target (row or donor) is a representative of the source run")
+    if why:
+        raise SystemExit(f"--reuse-from {src} refused: {why}")
+    order = sman["bulk_row_order"]
+    return {"binding": {"work": str(src), "run_signature": srun["run_signature"],
+                        "hvset_sha256": sprep["files"]["hvset.npy"],
+                        "seed_rule": "pretrain seeds = the source run's: base + 1000/2000 + row index in its bulk_row_order"},
+            "src": src, "prep": sprep, "signature": srun["run_signature"],
+            "seed_index": {r: order.index(r) for r in reps}}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--phase", choices=["prepare", "pretrain", "infer", "status", "link"], required=True)
+    ap.add_argument("--device", default="cuda:0")
+    ap.add_argument("--threads", type=int, default=4)
+    ap.add_argument("--max-reps", type=int, default=0, help="pretrain: at most N representatives this call (0 = all)")
+    ap.add_argument("--max-targets", type=int, default=0, help="infer: at most N targets this call (0 = all)")
+    ap.add_argument("--smoke", action="store_true")
+    ap.add_argument("--lean-hvset", action="store_true", help="prepare: streamed, output-identical hvset (see docstring)")
+    ap.add_argument("--reuse-from", type=Path, default=None, help="prepared source run whose hvset / pretraining is reused")
+    a = ap.parse_args(argv)
+    if not 1 <= a.threads <= 6:
+        ap.error("--threads must be 1..6")
+    if a.phase == "link" and a.reuse_from is None:
+        ap.error("--phase link needs --reuse-from")
+    for name in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS", "NUMBA_NUM_THREADS"):
+        os.environ[name] = str(a.threads)
+    work = a.work.resolve()
+    if a.smoke and "/scsemi/smoke/" not in str(work) + "/":
+        raise SystemExit("--smoke only under scsemi/smoke/")
+    if a.phase in ("prepare", "status", "link") and a.device != "cpu":
+        a.device = "cpu"
+    if a.device == "cpu" and os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+        raise SystemExit("CPU phases require CUDA_VISIBLE_DEVICES=''")
+    if a.device.startswith("cuda") and a.smoke:
+        raise SystemExit("smoke runs are CPU only")
+    inputs = work / "inputs"
+    project = work / "scsemi_project"
+    events = work / "events.jsonl"
+    protocol = json.loads(json.dumps(PROTOCOL))
+    if a.smoke:
+        for k, v in SMOKE_BUDGET.items():
+            protocol[k].update(v)
+        protocol["SMOKE"] = "reduced epoch budget; plumbing test only, never a benchmark output"
+    if a.lean_hvset and a.reuse_from is None:
+        protocol["hvset_impl"] = ("tools/lean_hvset.cohort_hvset_lean: streamed, one representative in memory; "
+                                  "output-identical to cohort_hvset (validation/hvset_dependence_20261002.json)")
+
+    def event(kind: str, **values) -> None:
+        v = {"at": datetime.now(timezone.utc).isoformat(), "event": kind, "phase": a.phase, **values,
+             "max_rss_gib": round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 2**20, 2)}
+        with events.open("a") as s:
+            s.write(json.dumps(v, default=str) + "\n")
+            s.flush()
+            os.fsync(s.fileno())
+        print(json.dumps(v, default=str), flush=True)
+
+    # shared code lock: tools/compat_patch_*.py replaces vendor files under the exclusive lock, so this call never
+    # verifies or imports a half-updated vendor; released once the vendor modules are imported
+    code_lock = open(HERE / ".code_update.lock", "a")
+    fcntl.flock(code_lock, fcntl.LOCK_SH)
+    man = json.loads((inputs / "inputs_manifest.json").read_text())
+    if bool(man.get("smoke")) != a.smoke:
+        raise SystemExit("smoke flag differs from the inputs' smoke flag")
+    for name, digest in man["files"].items():
+        if sha256(inputs / name) != digest:
+            raise SystemExit(f"input {name} differs from its manifest")
+    vendor = HERE / "vendor/scSemiProfiler"
+    source = json.loads((vendor.parent / "source_manifest.json").read_text())
+    for name, expected in source["files"].items():
+        if sha256(vendor / name) != expected:
+            raise SystemExit(f"vendor source hash mismatch: {name}")
+    assets = json.loads((HERE / "genesets/geneset_assets.json").read_text())
+    gmt_src = HERE / "genesets/c2.cp.v7.4.symbols.gmt"
+    if sha256(gmt_src) != assets["mapped_gmt_sha256"] or sha256(vendor / "genesets/c2.cp.v7.4.symbols.gmt") != assets["original_gmt_sha256"]:
+        raise SystemExit("gene-set asset hash mismatch")
+    versions = {n: importlib.metadata.version(n) for n in ["torch", "scvi-tools", "scanpy", "anndata", "lightning",
+                                                             "numpy", "scikit-learn", "faiss-cpu", "gseapy"]}
+    binding = {"protocol": protocol, "inputs": man["files"], "source": source, "environment": versions,
+               "wrapper_sha256": sha256(Path(__file__)), "lean_cellgraph_sha256": sha256(HERE / "tools/lean_cellgraph.py"),
+               "geneset_mapped_gmt_sha256": assets["mapped_gmt_sha256"]}
+    if a.lean_hvset and a.reuse_from is None:
+        binding["lean_hvset_sha256"] = sha256(HERE / "tools/lean_hvset.py")
+    reuse = None
+    if a.reuse_from is not None:
+        reuse = load_reuse_source(a.reuse_from.resolve(), work, man, protocol, binding)
+        binding["reuse"] = reuse["binding"]
+    code_signature = canonical_sha(binding)
+    run_file = work / "run_manifest.json"
+    migrations: list = []
+    if run_file.exists():
+        signature, migrations = resolve_run_identity(run_file, binding, code_signature)
+    else:
+        signature = code_signature
+    reps = [r["sample_id"] for r in man["representatives"]]
+    targets = list(man["target_order_test_samples"])
+    sids_expected = man["bulk_row_order"]
+    for s_ in sids_expected:
+        if not re.fullmatch(r"[A-Za-z0-9_.+-]+", s_):
+            raise SystemExit(f"unsafe sample id {s_!r}")
+    if not run_file.exists():
+        write_json(run_file, {"run_signature": signature, **binding, "work": str(work), "hostname": os.uname().nodename})
+
+    def status() -> dict:
+        pre = json.loads((work / "prepared.json").read_text()) if (work / "prepared.json").exists() else None
+        done_r = [r for r in reps if all((project / "models" / f"{b}{r}.receipt.json").exists()
+                                         for b in ("fast_reconst1_", "fastreconst2_"))]
+        done_t = [t for t in targets if (work / "shards" / f"{t}.json").exists()]
+        st = {"prepared": pre is not None, "n_reps": len(reps), "reps_pretrained": len(done_r),
+              "n_targets": len(targets), "targets_done": len(done_t),
+              "pretrain_complete": len(done_r) == len(reps), "infer_complete": len(done_t) == len(targets),
+              "run_signature": signature, "updated": datetime.now(timezone.utc).isoformat()}
+        write_json(work / "status.json", st)
+        return st
+
+    if a.phase == "status":
+        fcntl.flock(code_lock, fcntl.LOCK_UN)
+        print(json.dumps(status()))
+        return 0
+
+    import numpy as np
+    import anndata
+    import scipy.sparse as sp
+    sys.path.insert(0, str(vendor))
+    import torch
+    import scvi
+    import scSemiProfiler
+    from scSemiProfiler.inference import fastrecon, reconst_pretrain2, fast_semi
+    from scSemiProfiler.representative_selection import update_membership
+    fcntl.flock(code_lock, fcntl.LOCK_UN)
+    torch.set_num_threads(a.threads)
+    os.chdir(work)  # upstream reads "genesets/" and writes vaegan_train.txt relative to the cwd
+    event("start", run_signature=signature, code_signature=code_signature,
+          migrations=[m["transitions"] for m in migrations], device=a.device, host=os.uname().nodename)
+    try:
+        # ------------------------------------------------------------------ prepare (CPU)
+        prep = work / "prepared.json"
+        if a.phase == "prepare":
+            if prep.exists():
+                event("prepare_already_done")
+                status()
+                return 0
+            if project.exists():
+                raise SystemExit("partial upstream project without prepared.json; preserve and inspect")
+            gdir = work / "genesets"
+            gdir.mkdir(exist_ok=True)
+            shutil.copyfile(gmt_src, gdir / "c2.cp.v7.4.symbols.gmt")
+            t0 = time.monotonic()
+            P = protocol["initsetup"]
+            scSemiProfiler.initsetup(str(project), str(inputs / "bulk.h5ad"), logged=P["logged"], normed=P["normed"],
+                                     geneselection=P["geneselection"], batch=P["batch"])
+            if not (project / "processed_bulkdata.h5ad").exists():
+                raise SystemExit("upstream initsetup did not write processed_bulkdata.h5ad")
+            sids = [x.strip() for x in (project / "sids.txt").read_text().splitlines() if x.strip()]
+            if sids != sids_expected:
+                raise SystemExit("upstream sids.txt differs from the input bulk order")
+            rep_idx = [sids.index(r) for r in reps]
+            scSemiProfiler.set_representatives(str(project), rep_idx)
+            bulk = anndata.read_h5ad(project / "processed_bulkdata.h5ad")
+            pca = np.asarray(bulk.obsm["X_pca"], dtype=np.float64)
+            labels = update_membership(reduced_bulk=pca, representatives=rep_idx)
+            (project / "status/init_cluster_labels.txt").write_text("".join(f"{int(x)}\n" for x in labels))
+            dist = np.sqrt(((pca[:, None, :] - pca[rep_idx][None, :, :]) ** 2).sum(-1))
+            assign = {t: {"representative": reps[int(labels[sids.index(t)])],
+                          "distances": {reps[i]: float(dist[sids.index(t), i]) for i in range(len(reps))}} for t in targets}
+            for i, r in enumerate(reps):
+                if int(labels[sids.index(r)]) != i:
+                    raise SystemExit(f"representative {r} not assigned to itself")
+            write_json(work / "assignment.json", {"rule": protocol["assignment"], "n_pca_components": int(pca.shape[1]),
+                                                  "bulk_row_order": sids, "representative_indices": rep_idx,
+                                                  "targets": assign,
+                                                  "targets_per_representative": {r: sum(v["representative"] == r for v in assign.values()) for r in reps}})
+            del bulk
+            S = protocol["scprocess"]
+            import scSemiProfiler.singlecell_process as upstream_sp
+            sys.path.insert(0, str(HERE / "tools"))
+            from lean_cellgraph import fast_cellgraph_lean
+            upstream_sp.fast_cellgraph = fast_cellgraph_lean   # resolved from module globals inside scprocess
+            if S["logged"] or S["normed"] or S["cellfilter"] or S["geneset"] is not True:
+                raise SystemExit("cohort_hvset replicates the logged=False, normed=False, cellfilter=False, geneset=True path only")
+            (project / "geneset_scores").mkdir(exist_ok=True)
+            if reuse is not None:      # the source run's hvset (byte copy, sha-checked); upstream scprocess skips hvset
+                src_hv = reuse["src"] / "scsemi_project/hvset.npy"
+                if sha256(src_hv) != reuse["binding"]["hvset_sha256"]:
+                    raise SystemExit(f"{src_hv} differs from the source run's prepared.json")
+                shutil.copyfile(src_hv, project / "hvset.npy")
+                event("hvset_copied_from_source", source=str(reuse["src"]))
+            elif a.lean_hvset:
+                from lean_hvset import cohort_hvset_lean
+                cohort_hvset_lean(project, inputs / "rep_sc.h5ad", S["threshold"])
+                event("cohort_hvset_done", impl="lean_hvset")
+            else:
+                cohort_hvset(project, inputs / "rep_sc.h5ad", S["threshold"])
+                event("cohort_hvset_done")
+            R = anndata.read_h5ad(inputs / "rep_sc.h5ad")
+            per_rep = work / "inputs_per_rep"
+            per_rep.mkdir(exist_ok=True)
+            for r in reps:
+                f_r = per_rep / f"{r}.h5ad"
+                R[(R.obs["sample_ids"] == r).to_numpy()].copy().write_h5ad(f_r)
+                scSemiProfiler.scprocess(str(project), str(f_r), logged=S["logged"], normed=S["normed"],
+                                         cellfilter=S["cellfilter"], threshold=S["threshold"], geneset=S["geneset"],
+                                         weight=S["weight"], k=S["k"])
+                f_r.unlink()
+                gc.collect()
+            per_rep.rmdir()
+            del R
+            genes = man["modeled_genes"]["gene_ids"]
+            if np.load(project / "hvgenes.npy", allow_pickle=True).astype(str).tolist() != genes:
+                raise SystemExit("upstream altered the modeled gene axis")
+            hvset = np.load(project / "hvset.npy", allow_pickle=False).astype(bool)
+            if hvset.shape != (2922,) or not hvset.any():
+                raise SystemExit("no variable gene-set features selected; refuse silent no-geneset fallback")
+            qc = {"selected_gene_sets": int(hvset.sum()), "reps": {}}
+            for r in reps:
+                f_sc, f_gs = project / "sample_sc" / f"{r}.h5ad", project / "geneset_scores" / f"{r}.npy"
+                if not f_sc.exists() or not f_gs.exists():
+                    raise SystemExit(f"upstream scprocess did not write {r}")
+                g = np.load(f_gs, allow_pickle=False)
+                if not np.isfinite(g).all() or (g < 0).any():
+                    raise SystemExit(f"{r}: non-finite / negative gene-set scores")
+                h = anndata.read_h5ad(f_sc, backed="r")
+                X = np.asarray(h.X[:])
+                n_feat = len(h.uns["feature_var"])
+                if h.var_names.astype(str).tolist() != genes or n_feat != len(genes) + int(hvset.sum()):
+                    raise SystemExit(f"{r}: prepared axis / feature variance length mismatch")
+                glib = X.sum(1)
+                slib = g[:, hvset].sum(1)
+                h.file.close()
+                if g.shape[0] != X.shape[0]:
+                    raise SystemExit(f"{r}: gene-set score rows differ from cells")
+                if (glib <= 0).any() or (slib <= 0).any():
+                    raise SystemExit(f"{r}: {int((glib <= 0).sum())} cells with empty thresholded gene library, "
+                                     f"{int((slib <= 0).sum())} with empty selected gene-set library (log would be -inf)")
+                qc["reps"][r] = {"n_cells": int(X.shape[0]), "median_thresholded_gene_library": float(np.median(glib)),
+                                 "median_nonzero_genes": float(np.median((X > 0).sum(1))),
+                                 "zero_score_pathways": int(np.all(g == 0, axis=0).sum())}
+                del X, g
+            files = ["processed_bulkdata.h5ad", "hvgenes.npy", "sids.txt", "hvset.npy", "hvmask.npy",
+                     "status/init_representatives.txt", "status/init_cluster_labels.txt"]
+            files += [f"sample_sc/{r}.h5ad" for r in reps] + [f"geneset_scores/{r}.npy" for r in reps]
+            write_json(work / "geneset_feature_qc.json", {"run_signature": signature, **qc})
+            file_sha = {f: sha256(project / f) for f in files}
+            extra = {}
+            if reuse is not None:      # every pretraining input of every representative must be the source run's bytes
+                keys = ["hvset.npy"] + [f"sample_sc/{r}.h5ad" for r in reps] + [f"geneset_scores/{r}.npy" for r in reps]
+                bad = [k for k in keys if file_sha[k] != reuse["prep"]["files"].get(k)]
+                if bad:
+                    raise SystemExit(f"prepared files differ from the source run {reuse['src']}: {bad[:6]}")
+                extra["reuse_check"] = {"source_work": str(reuse["src"]), "source_run_signature": reuse["signature"],
+                                        "identical_files": keys, "all_identical": True}
+                event("reuse_check_passed", n_files=len(keys))
+            write_json(prep, {"run_signature": signature, "seconds": round(time.monotonic() - t0, 1),
+                              "files": file_sha,
+                              "genesets_gmt_sha256": sha256(gdir / "c2.cp.v7.4.symbols.gmt"), **extra})
+            event("prepared", seconds=round(time.monotonic() - t0, 1), selected_gene_sets=int(hvset.sum()))
+            status()
+            return 0
+
+        # ------------------------------------------------------------------ GPU phases
+        if not prep.exists():
+            raise SystemExit("run --phase prepare first")
+        prepared = json.loads(prep.read_text())
+        if prepared["run_signature"] != signature:
+            raise SystemExit("prepared.json belongs to another run signature")
+        for name, digest in prepared["files"].items():
+            if name.startswith("sample_sc/"):
+                continue  # large; verified per representative when used
+            if sha256(project / name) != digest:
+                raise SystemExit(f"prepared file changed: {name}")
+        sids = [x.strip() for x in (project / "sids.txt").read_text().splitlines() if x.strip()]
+        assign = json.loads((work / "assignment.json").read_text())["targets"]
+        for sub in ("models", "history", "tmp", "inferreddata"):
+            (project / sub).mkdir(exist_ok=True)
+        verified_sc: set[str] = set()
+
+        def verify_sc(r: str) -> None:
+            if r not in verified_sc:
+                if sha256(project / f"sample_sc/{r}.h5ad") != prepared["files"][f"sample_sc/{r}.h5ad"]:
+                    raise SystemExit(f"prepared sample_sc/{r}.h5ad changed")
+                verified_sc.add(r)
+
+        def ckpt_ok(path: Path) -> bool:
+            rp = path.with_name(path.name + ".receipt.json")
+            if not path.exists():
+                if rp.exists():
+                    raise SystemExit(f"receipt without checkpoint: {rp}")
+                return False
+            if not rp.exists():
+                raise SystemExit(f"unreceipted checkpoint {path}; preserve and inspect")
+            rec = json.loads(rp.read_text())
+            if rec["run_signature"] != signature or rec["sha256"] != sha256(path):
+                raise SystemExit(f"checkpoint receipt mismatch: {path}")
+            return True
+
+        def shim(state_path: Path):
+            sd = torch.load(state_path, map_location=a.device, weights_only=True)
+            return types.SimpleNamespace(module=types.SimpleNamespace(state_dict=lambda: sd))
+
+        if a.phase == "link":   # CPU: reuse the source run's receipted pretrain checkpoints (hard link, sha-checked)
+            smodels = reuse["src"] / "scsemi_project/models"
+            n_link = n_missing = 0
+            for r in reps:
+                for stage, base in ((1, "fast_reconst1_"), (2, "fastreconst2_")):
+                    dst = project / "models" / f"{base}{r}"
+                    if ckpt_ok(dst):
+                        continue
+                    src = smodels / f"{base}{r}"
+                    srp = src.with_name(src.name + ".receipt.json")
+                    if not (src.exists() and srp.exists()):
+                        n_missing += 1
+                        event("link_source_missing", representative=r, stage=stage)
+                        continue
+                    srec = json.loads(srp.read_text())
+                    want_seed = SEED + 1000 * stage + reuse["seed_index"][r]
+                    if not (srec.get("complete") and srec["run_signature"] == reuse["signature"] and srec["stage"] == stage
+                            and srec["representative"] == r and srec["seed"] == want_seed and srec["sha256"] == sha256(src)):
+                        raise SystemExit(f"source checkpoint {src} does not match its receipt, the source run or the seed")
+                    try:
+                        os.link(src, dst)
+                    except OSError:
+                        shutil.copy2(src, dst)
+                    if sha256(dst) != srec["sha256"]:
+                        raise SystemExit(f"linked checkpoint {dst} differs from its source")
+                    write_json(dst.with_name(dst.name + ".receipt.json"), {
+                        "run_signature": signature, "sha256": srec["sha256"], "stage": stage, "representative": r,
+                        "seed": want_seed, "elapsed_seconds": 0.0, "code_signature": code_signature,
+                        "device": srec.get("device"), "complete": True,
+                        "reused_from": {"path": str(src), "run_signature": reuse["signature"], "receipt": srec}})
+                    n_link += 1
+            st = status()
+            event("link_done", linked=n_link, source_missing=n_missing,
+                  **{k: st[k] for k in ("reps_pretrained", "n_reps")})
+            return 0
+
+        if a.phase == "pretrain":
+            P1, P2 = protocol["pretrain1"], protocol["pretrain2"]
+            n_done = 0
+            for r in reps:
+                c1 = project / "models" / f"fast_reconst1_{r}"
+                c2 = project / "models" / f"fastreconst2_{r}"
+                ok1, ok2 = ckpt_ok(c1), ckpt_ok(c2)
+                if ok1 and ok2:
+                    continue
+                if a.max_reps and n_done >= a.max_reps:
+                    break
+                verify_sc(r)
+                idx = reuse["seed_index"][r] if reuse is not None else sids.index(r)
+                model1 = None
+                if not ok1:
+                    scvi.settings.seed = SEED + 1000 + idx
+                    event("pretrain_start", stage=1, representative=r, seed=SEED + 1000 + idx)
+                    t0 = time.monotonic()
+                    model1 = fastrecon(str(project), r, device=a.device, k=P1["k"], diagw=P1["diagw"],
+                                       vaesteps=P1["vaesteps"], gansteps=P1["gansteps"], lr=P1["lr"])
+                    el = time.monotonic() - t0
+                    write_json(c1.with_name(c1.name + ".receipt.json"), {"run_signature": signature, "sha256": sha256(c1),
+                               "stage": 1, "representative": r, "seed": SEED + 1000 + idx, "elapsed_seconds": el,
+                               "code_signature": code_signature,
+                               "device": a.device, "complete": True})
+                    event("pretrain_complete", stage=1, representative=r, elapsed_seconds=round(el, 1))
+                if not ok2:
+                    pre = model1 if model1 is not None else shim(c1)
+                    scvi.settings.seed = SEED + 2000 + idx
+                    event("pretrain_start", stage=2, representative=r, seed=SEED + 2000 + idx)
+                    t0 = time.monotonic()
+                    model2 = reconst_pretrain2(str(project), r, pre, device=a.device, k=P2["k"], diagw=P2["diagw"],
+                                               vaesteps=P2["vaesteps"], gansteps=P2["gansteps"], lr=P2["lr"])
+                    el = time.monotonic() - t0
+                    write_json(c2.with_name(c2.name + ".receipt.json"), {"run_signature": signature, "sha256": sha256(c2),
+                               "stage": 2, "representative": r, "seed": SEED + 2000 + idx, "elapsed_seconds": el,
+                               "code_signature": code_signature,
+                               "device": a.device, "complete": True})
+                    event("pretrain_complete", stage=2, representative=r, elapsed_seconds=round(el, 1))
+                    del model2
+                del model1
+                gc.collect()
+                if a.device.startswith("cuda"):
+                    torch.cuda.empty_cache()
+                n_done += 1
+            st = status()
+            event("pretrain_call_done", reps_this_call=n_done, **{k: st[k] for k in ("reps_pretrained", "n_reps")})
+            return 0
+
+        if a.phase == "infer":
+            I = protocol["infer"]
+            missing = [r for r in reps if not (ckpt_ok(project / "models" / f"fast_reconst1_{r}")
+                                               and ckpt_ok(project / "models" / f"fastreconst2_{r}"))]
+            if missing:
+                raise SystemExit(f"pretraining incomplete for {missing}")
+            shards = work / "shards"
+            shards.mkdir(exist_ok=True)
+            genelen = len(man["modeled_genes"]["gene_ids"])
+            n_done = 0
+            for t in targets:
+                rec_path = shards / f"{t}.json"
+                shard = shards / f"{t}.npz"
+                if rec_path.exists():
+                    rec = json.loads(rec_path.read_text())
+                    if rec["run_signature"] != signature or rec["shard_sha256"] != sha256(shard):
+                        raise SystemExit(f"target shard receipt mismatch: {t}")
+                    continue
+                if shard.exists():
+                    raise SystemExit(f"shard without receipt: {shard}; preserve and inspect")
+                if a.max_targets and n_done >= a.max_targets:
+                    break
+                r = assign[t]["representative"]
+                verify_sc(r)
+                upstream = project / "inferreddata" / f"{r}_to_{t}.npy"
+                if upstream.exists():
+                    raise SystemExit(f"unreceipted upstream output {upstream}; preserve and inspect")
+                rid, tid = sids.index(r), sids.index(t)
+                scvi.settings.seed = SEED + tid
+                event("target_start", sample_id=t, representative=r, seed=SEED + tid)
+                t0 = time.monotonic()
+                fast_semi(str(project), rid, tid, str(project / "models" / f"fastreconst2_{r}"), device=a.device,
+                          k=I["k"], diagw=I["diagw"], bulktype=I["bulktype"], pseudocount=I["pseudocount"], lr=I["lr"],
+                          epochs=I["epochs"], ministages=I["ministages"])
+                elapsed = time.monotonic() - t0
+                M = np.load(upstream, allow_pickle=False)
+                n_rep_cells = json.loads((work / "geneset_feature_qc.json").read_text())["reps"][r]["n_cells"]
+                if M.shape != (n_rep_cells, genelen) or not np.isfinite(M).all() or (M < 0).any():
+                    raise SystemExit(f"{t}: invalid upstream output {M.shape} (expected {(n_rep_cells, genelen)})")
+                C = sp.csr_matrix(M)
+                tmp = shards / f"{t}.tmp.npz"
+                sp.save_npz(tmp, C, compressed=False)
+                back = sp.load_npz(tmp).toarray()
+                if back.dtype != M.dtype or not np.array_equal(back, M):
+                    raise SystemExit(f"{t}: CSR re-encoding is not lossless")
+                tmp.replace(shard)
+                lib = M.sum(1)
+                rec = {"sample_id": t, "representative": r, "rep_bulk_index": rid, "target_bulk_index": tid,
+                       "seed": SEED + tid, "elapsed_seconds": elapsed, "device": a.device, "run_signature": signature,
+                       "code_signature": code_signature,
+                       "shape": list(M.shape), "dtype": str(M.dtype), "nnz": int(C.nnz),
+                       "zero_fraction": float(1 - C.nnz / M.size), "zero_rows": int((lib == 0).sum()),
+                       "mean_library_normalized": float(lib.mean()), "matrix_unit": "normalized_expression",
+                       "upstream_npy": str(upstream), "upstream_npy_sha256": sha256(upstream),
+                       "shard": str(shard), "shard_sha256": sha256(shard), "lossless_csr_verified": True,
+                       "upstream_npy_removed": True, "created_at": datetime.now(timezone.utc).isoformat(), "complete": True}
+                write_json(rec_path, rec)
+                upstream.unlink()   # dense copy of a verified lossless shard (disk)
+                del M, C, back
+                gc.collect()
+                n_done += 1
+                event("target_complete", sample_id=t, representative=r, elapsed_seconds=round(elapsed, 2),
+                      zero_rows=rec["zero_rows"], zero_fraction=round(rec["zero_fraction"], 4))
+            st = status()
+            event("infer_call_done", targets_this_call=n_done, **{k: st[k] for k in ("targets_done", "n_targets")})
+            return 0
+    except BaseException as exc:
+        event("failed", error_type=type(exc).__name__, message=str(exc)[:2000])
+        raise
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/extra_metrics.py

@@ -0,0 +1,876 @@
+#!/usr/bin/env python3
+"""Reviewer-expected realism / diversity metrics for the paired fine-tuning benchmark (CPU only; never imports torch).
+
+Added 2026-10-01. Every scored unit (one few-pair draw, or one pooled 5-fold call) is re-read exactly as tools/score_ft.py
+scored it, and four metric families are added next to the existing precision/coverage:
+
+  1. classifier two-sample tests (real vs generated): kNN (k = 5) and random-forest 5-fold cross-validated ROC AUC
+     (scGAN / scDiffusion style) and the leave-one-out 1-NN accuracy (scLDM; Lopez-Paz & Oquab 2017);
+  2. MMD^2 (unbiased, Gaussian RBF; median-heuristic bandwidth and the fixed multiples 0.5 / 1 / 2, plus their sum);
+  3. scSemiProfiler's normalized error E_N (Wang et al. 2024, Methods eq. 17-18; get_error in vendor utils.py);
+  4. precision / coverage at k = 3 and 5 next to k = 10 (k = 10 re-computed first and checked against score_ft.py).
+
+Families 1, 2 and 4 use exactly the scorer's embedding and cells: score_ft.make_view (PCA-50 fitted on the scored
+donors' R1 cells), the scorer's whole-NPZ Poisson read-out (seed 20260916), its donor-keyed generated subsample
+(F.generated_subsample) and its pairwise depth matching (F.SB.depth_match with a fresh rng(20260929)). They are
+reported both without ("raw", the deck's headline precision/coverage) and with depth matching ("dm"). The
+real-vs-real control is the scorer's own: held-out real cells R2 of the same donors, same n per donor.
+
+E_N follows scSemiProfiler's own space instead: per arm, log1p CP10K -> PCA-100 fitted on real and generated cells
+together; Dif_sc = symmetric 1-NN distance (eq. 17); lower bound = random half split of the whole PCA matrix; upper
+bound = random pairs of different real samples. Distances: squared L2 as their code computes them (faiss
+IndexFlatL2), and plain L2 as the paper's text writes them. Two cell sets:
+  "all": every observed QC cell of each scored sample vs all of its generated cells (their setting);
+         control = a random within-sample half split of the observed cells (half A as 'real', half B as 'generated').
+  "pc":  the precision/coverage cells (R1 vs the generated subsample, n per donor equal); control = R1 vs R2.
+Representatives: scSemiProfiler sets a representative's error to the lower bound. Our scored samples never include a
+representative (the 5 training donors of a few-pair draw are not scored in any arm), so no sample is set to LB; for
+scsemi5 the table also gives the value that convention would produce (E_N x n_test / (n_test + n_representative_rows)).
+
+usage (CPU; run through tools/run_extra_unit.sh):
+  extra_metrics.py --design fewshot --dataset giroux2022 --draws 0,1,2,3,4 [--threads 7] [--no-en-all]
+  extra_metrics.py --design pooled  --dataset giroux2022
+  extra_metrics.py --collect                     # scores_extra/*.csv + TABLES.md from every unit written so far
+  extra_metrics.py --design scored --dataset immicro --score-dir scores/immicro/scsemi_cv_20261002/pooled \
+      --arms scsemi__raw --unit scsemi_cv_20261002/pooled      # (2026-10-02) any scored call + arms -> new sub-path;
+                                                               # --collect does not read these units
+Outputs: scores_extra/<dataset>/<fewshot_n5/draw<j> | pooled>/{metrics.csv, per_donor.csv, en.csv, en_per_sample.csv,
+         repro.json, manifest.json}.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _threads_from_argv(default: int = 7) -> int:
+    for i, a in enumerate(sys.argv):
+        if a == "--threads" and i + 1 < len(sys.argv):
+            return int(sys.argv[i + 1])
+        if a.startswith("--threads="):
+            return int(a.split("=", 1)[1])
+    return default
+
+
+_THR = str(_threads_from_argv())
+for _k in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", "NUMBA_NUM_THREADS"):
+    os.environ[_k] = _THR
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+import argparse  # noqa: E402
+import hashlib  # noqa: E402
+import json  # noqa: E402
+import shutil  # noqa: E402
+import subprocess  # noqa: E402
+import time  # noqa: E402
+from pathlib import Path  # noqa: E402
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import scipy.sparse as sp  # noqa: E402
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import ft_common as F  # noqa: E402
+import score_ft as S  # noqa: E402  (module level: argparse/env only; main() is not run)
+
+TASK = F.TASK
+SCORES = TASK / "scores"
+CODE_FILES = (Path(__file__).resolve(), TOOLS / "ft_common.py", TOOLS / "score_ft.py", F.SB_PATH)
+OUT_ROOT = TASK / "scores_extra"
+REMOTE = "spark-0110"
+MIN_FREE_GIB = 40.0
+
+SEED = 20261001                      # every new random stream of this file (CV folds, RF, bandwidth subsample, E_N)
+KS = (3, 5, 10)
+KNN_C2ST_K = 5                       # sklearn default, scDiffusion's kNN classifier
+RF_TREES = 300                       # scGAN: fully grown trees, max_features = sqrt; 300 instead of 1000 trees (cost)
+CV_FOLDS = 5                         # scGAN: five-fold cross-validation, equal real / generated counts
+BW_MULTIPLES = (0.5, 1.0, 2.0)       # scGAN: sigma in {m/2, m, 2m}
+BW_MAX_CELLS = 4000                  # R1 cells used for the median pairwise distance
+EN_PCS = 100                         # scSemiProfiler: PCA to 100 dimensions
+EN_LB_MAX_QUERIES = 20000            # all-cells E_N: LB estimated from this many query cells per direction (index = full half)
+EN_CHUNK = 8192
+
+FEW_ARMS = ("zs_raw", "zs_cal", "scsemi5", "lora5", "zs_pseudo")
+POOLED_ARMS = ("zs__raw", "zs__cal", "pseudo_full__cal", "real_lora__raw", "zs__pseudo")
+CONTROL = "real_R2"                  # R1 vs R2 (P/C cells) / within-sample half split (all cells)
+CONTROL_OOS = "real_R3"              # out-of-sample real side: R2' vs R3 (families 1-2)
+ARM_LABEL = {"zs_raw": "Zero-shot, real bulk", "zs__raw": "Zero-shot, real bulk",
+             "zs_cal": "Zero-shot + calibration", "zs__cal": "Zero-shot + calibration",
+             "scsemi5": "scSemiProfiler, 5 donors", "lora5": "LoRA, 5 donors",
+             "real_lora__raw": "LoRA, all training pairs", "pseudo_full__cal": "sc-only fine-tune (+ calibration)",
+             "zs_pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             "zs__pseudo": "Zero-shot, sc pseudobulk input (reference)",
+             CONTROL: "Real vs real control (held-out real cells)",
+             CONTROL_OOS: "Real vs real control (out-of-sample: R2 vs R3)"}
+# --design scored (added 2026-10-02): any existing score_ft.py call dir and arms, output under scores_extra/<ds>/<unit>
+ARM_LABEL.update({"scsemi__raw": "scSemiProfiler, all training pairs (5-fold CV)",
+                  **{f"scsemi_n{n}__raw": f"scSemiProfiler, {n} pairs + inner-val (equal budget)" for n in (5, 10, 20, 40)},
+                  **{f"lora_n{n}__raw": f"LoRA, {n} pairs + inner-val" for n in (5, 10, 20, 40)}})
+SCORED: dict = {}                    # {"dir": Path, "arms": tuple, "unit": str}; set by main for --design scored
+DATASETS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def log(msg: str) -> None:
+    F.log(msg)
+
+
+# =========================================================================== pure metric functions
+def sqdist_min(Q: np.ndarray, X: np.ndarray, *, exclude_self: bool = False, max_block: float = 1.5e8) -> tuple:
+    """For every row of Q: the minimum squared L2 distance to the rows of X and its index (brute force, float64,
+    chunked BLAS). exclude_self: Q is X and the diagonal is skipped (leave-one-out)."""
+    Q = np.ascontiguousarray(Q, dtype=np.float64)
+    X = np.ascontiguousarray(X, dtype=np.float64)
+    xx = np.einsum("ij,ij->i", X, X)
+    qq = np.einsum("ij,ij->i", Q, Q)
+    out = np.empty(Q.shape[0])
+    arg = np.empty(Q.shape[0], dtype=np.int64)
+    chunk = max(16, int(max_block // max(X.shape[0], 1)))
+    for s in range(0, Q.shape[0], chunk):
+        e = min(s + chunk, Q.shape[0])
+        D = qq[s:e, None] + xx[None, :] - 2.0 * (Q[s:e] @ X.T)
+        if exclude_self:
+            D[np.arange(e - s), np.arange(s, e)] = np.inf
+        a = np.argmin(D, axis=1)
+        arg[s:e] = a
+        out[s:e] = np.maximum(D[np.arange(e - s), a], 0.0)
+    return out, arg
+
+
+def one_nn_loo(zr: np.ndarray, zg: np.ndarray) -> dict:
+    """Leave-one-out 1-NN two-sample accuracy (Lopez-Paz & Oquab 2017; scLDM eq. 32): pool both sets, predict each
+    point's label by its nearest other point; 0.5 = indistinguishable, 1 = separable."""
+    Z = np.vstack([zr, zg])
+    y = np.r_[np.ones(len(zr), bool), np.zeros(len(zg), bool)]
+    _, a = sqdist_min(Z, Z, exclude_self=True)
+    ok = y[a] == y
+    return {"nn1_acc": float(ok.mean()), "nn1_acc_real": float(ok[y].mean()), "nn1_acc_gen": float(ok[~y].mean())}
+
+
+def c2st_auc(zr: np.ndarray, zg: np.ndarray, *, kind: str, seed: int = SEED, n_jobs: int = 1) -> dict:
+    """Classifier two-sample test: stratified 5-fold CV ROC AUC of real (1) vs generated (0); mean and SD over folds."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.metrics import roc_auc_score
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.neighbors import KNeighborsClassifier
+    Z = np.vstack([zr, zg]).astype(np.float32)
+    y = np.r_[np.ones(len(zr), np.int8), np.zeros(len(zg), np.int8)]
+    aucs = []
+    for tr, te in StratifiedKFold(CV_FOLDS, shuffle=True, random_state=seed).split(Z, y):
+        if kind == "knn":
+            clf = KNeighborsClassifier(n_neighbors=KNN_C2ST_K, n_jobs=n_jobs)
+        elif kind == "rf":
+            clf = RandomForestClassifier(n_estimators=RF_TREES, max_features="sqrt", n_jobs=n_jobs, random_state=seed)
+        else:
+            raise ValueError(kind)
+        clf.fit(Z[tr], y[tr])
+        p = clf.predict_proba(Z[te])[:, list(clf.classes_).index(1)]
+        aucs.append(roc_auc_score(y[te], p))
+    return {f"c2st_{kind}_auc": float(np.mean(aucs)), f"c2st_{kind}_auc_sd": float(np.std(aucs, ddof=1))}
+
+
+def median_bandwidth(z: np.ndarray, *, seed: int = SEED, max_cells: int = BW_MAX_CELLS) -> float:
+    """Median heuristic (Gretton et al. 2012): median pairwise Euclidean distance among (<= max_cells) real cells."""
+    rng = np.random.default_rng(seed)
+    idx = np.sort(rng.choice(len(z), size=min(max_cells, len(z)), replace=False))
+    x = np.asarray(z[idx], np.float64)
+    sq = np.einsum("ij,ij->i", x, x)
+    D = np.maximum(sq[:, None] + sq[None, :] - 2 * x @ x.T, 0.0)
+    iu = np.triu_indices(len(x), 1)
+    return float(np.sqrt(np.median(D[iu])))
+
+
+def _kernel_sums(A: np.ndarray, B: np.ndarray, sigmas, same: bool, max_block: float = 6e7) -> np.ndarray:
+    """sum over pairs of exp(-||a - b||^2 / (2 sigma^2)) for every sigma (diagonal excluded when same)."""
+    A = np.ascontiguousarray(A, np.float64)
+    B = np.ascontiguousarray(B, np.float64)
+    aa, bb = np.einsum("ij,ij->i", A, A), np.einsum("ij,ij->i", B, B)
+    g = np.asarray([1.0 / (2.0 * s * s) for s in sigmas])
+    tot = np.zeros(len(sigmas))
+    chunk = max(16, int(max_block // max(len(B), 1)))
+    for s in range(0, len(A), chunk):
+        e = min(s + chunk, len(A))
+        D = np.maximum(aa[s:e, None] + bb[None, :] - 2.0 * (A[s:e] @ B.T), 0.0)
+        for i, gi in enumerate(g):
+            K = np.exp(-gi * D)
+            if same:
+                K[np.arange(e - s), np.arange(s, e)] = 0.0
+            tot[i] += K.sum()
+    return tot
+
+
+def mmd2_unbiased(zr: np.ndarray, zg: np.ndarray, sigmas) -> np.ndarray:
+    """Unbiased MMD^2 (Gretton et al. 2012, eq. 3) with Gaussian RBF k(x, y) = exp(-||x - y||^2 / (2 sigma^2)), one value
+    per sigma; the kernel sum over the sigmas (scGAN's multi-scale kernel) is the sum of the per-sigma values."""
+    n, m = len(zr), len(zg)
+    kxx = _kernel_sums(zr, zr, sigmas, True) / (n * (n - 1))
+    kyy = _kernel_sums(zg, zg, sigmas, True) / (m * (m - 1))
+    kxy = _kernel_sums(zr, zg, sigmas, False) / (n * m)
+    return kxx + kyy - 2.0 * kxy
+
+
+def pc_at_k(zr: np.ndarray, zg: np.ndarray, k: int) -> dict:
+    """Kynkaanniemi precision and Naeem coverage / density with k-NN balls of the real set: the scorer's own
+    stage_b_embed functions (knn_radius, precision_coverage). density is rescaled from SB's fixed k = 10 to k."""
+    radius = F.SB.knn_radius(zr, k)
+    r = F.SB.precision_coverage(zr, radius, zg)
+    r["density"] = r["density"] * F.K_NN / k
+    return r
+
+
+def expected_coverage(n_real: int, n_gen: int, k: int) -> float:
+    """Naeem et al. 2020, eq. 9: E[coverage] for identical real and fake distributions."""
+    num = np.prod([(n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    den = np.prod([(n_gen + n_real - i) for i in range(1, k + 1)], dtype=np.float64)
+    return float(1.0 - num / den)
+
+
+def two_sample_block(zr: np.ndarray, zg: np.ndarray, sigma_m: float, *, n_jobs: int, rf: bool = True) -> dict:
+    out = {}
+    out.update(c2st_auc(zr, zg, kind="knn", n_jobs=n_jobs))
+    if rf:
+        out.update(c2st_auc(zr, zg, kind="rf", n_jobs=n_jobs))
+    out.update(one_nn_loo(zr, zg))
+    sig = [m * sigma_m for m in BW_MULTIPLES]
+    mm = mmd2_unbiased(zr, zg, sig)
+    for mult, val in zip(BW_MULTIPLES, mm):
+        out[f"mmd2_bw{mult:g}"] = float(val)
+    out["mmd2_sum"] = float(mm.sum())
+    out["mmd_bandwidth_m"] = float(sigma_m)
+    return out
+
+
+# =========================================================================== scSemiProfiler E_N
+def log1p_cp10k_sparse(X: sp.csr_matrix) -> sp.csr_matrix:
+    """SB.cp10k_log1p (per-cell CP10K over the columns, log1p; empty cells stay zero) kept sparse, float32."""
+    X = X.tocsr().astype(np.float64)
+    lib = np.asarray(X.sum(axis=1)).ravel()
+    D = (sp.diags(np.divide(F.CP10K, lib, out=np.zeros_like(lib), where=lib > 0)) @ X).tocsr()
+    D.data = np.log1p(D.data)
+    return D.astype(np.float32)
+
+
+class Gram:
+    """Running X^T X, column sums and row count of log1p-CP10K features (float64), for an exact PCA by eigh of the
+    covariance (the solver sklearn's PCA calls covariance_eigh; equal to the full-SVD PCA up to component signs)."""
+
+    def __init__(self, p: int):
+        self.G = np.zeros((p, p))
+        self.s = np.zeros(p)
+        self.n = 0
+
+    def add(self, L: sp.csr_matrix, chunk: int = EN_CHUNK) -> "Gram":
+        for a in range(0, L.shape[0], chunk):
+            B = L[a:a + chunk].toarray()                       # float32 (log1p CP10K)
+            self.G += (B.T @ B).astype(np.float64)              # sgemm within a chunk, float64 across chunks
+            self.s += B.sum(0, dtype=np.float64)
+            self.n += B.shape[0]
+        return self
+
+    def __add__(self, other: "Gram") -> "Gram":
+        g = Gram(len(self.s))
+        g.G, g.s, g.n = self.G + other.G, self.s + other.s, self.n + other.n
+        return g
+
+    def pca(self, n_comp: int = EN_PCS) -> tuple[np.ndarray, np.ndarray]:
+        from scipy.linalg import eigh
+        p = len(self.s)
+        n_comp = int(min(n_comp, p, self.n - 1))
+        mu = self.s / self.n
+        C = (self.G - self.n * np.outer(mu, mu)) / (self.n - 1)
+        w, V = eigh(C, subset_by_index=[p - n_comp, p - 1])
+        return mu, np.ascontiguousarray(V[:, ::-1].T)          # components x genes, descending variance
+
+
+def embed(L: sp.csr_matrix, mu: np.ndarray, comps: np.ndarray, chunk: int = EN_CHUNK) -> np.ndarray:
+    """(x - mu) @ comps.T for sparse features x (dense row chunks, float64 BLAS)."""
+    out = np.empty((L.shape[0], comps.shape[0]))
+    for a in range(0, L.shape[0], chunk):
+        out[a:a + chunk] = (L[a:a + chunk].toarray().astype(np.float64) - mu) @ comps.T
+    return out
+
+
+def dif_sc(a: np.ndarray, b: np.ndarray) -> dict:
+    """scSemiProfiler eq. 17 with K = 1: mean over the cells of both samples of the distance to the nearest cell of the
+    other sample. 'sq' = squared L2 (their code: faiss IndexFlatL2), 'l2' = L2 (their text)."""
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    n = len(a) + len(b)
+    return {"sq": float((da.sum() + db.sum()) / n), "l2": float((np.sqrt(da).sum() + np.sqrt(db).sum()) / n)}
+
+
+def lower_bound(Z: np.ndarray, rng: np.random.Generator, max_queries: int | None) -> dict:
+    """LB: random half split of the whole PCA matrix (real + generated), symmetric 1-NN (their code: shuffle, first
+    n//2 rows vs the rest). With max_queries, each direction averages max_queries random query cells of one half
+    against the complete other half (an unbiased estimate of the same mean)."""
+    perm = rng.permutation(len(Z))
+    h = len(Z) // 2
+    A, B = Z[perm[:h]], Z[perm[h:]]
+    qa = A if (max_queries is None or len(A) <= max_queries) else A[np.sort(rng.choice(len(A), max_queries, replace=False))]
+    qb = B if (max_queries is None or len(B) <= max_queries) else B[np.sort(rng.choice(len(B), max_queries, replace=False))]
+    da, _ = sqdist_min(qa, B)
+    db, _ = sqdist_min(qb, A)
+    exact = len(qa) == len(A) and len(qb) == len(B)
+    if exact:   # their arithmetic: mean over the concatenated distances of both directions
+        sq = float((da.sum() + db.sum()) / (len(da) + len(db)))
+        l2 = float((np.sqrt(da).sum() + np.sqrt(db).sum()) / (len(da) + len(db)))
+    else:       # same weights as the exact concatenation (|A| and |B| cells), each direction estimated
+        wa, wb = len(A) / (len(A) + len(B)), len(B) / (len(A) + len(B))
+        sq = float(wa * da.mean() + wb * db.mean())
+        l2 = float(wa * np.sqrt(da).mean() + wb * np.sqrt(db).mean())
+    return {"sq": sq, "l2": l2, "exact": exact, "n_queries": [int(len(qa)), int(len(qb))], "n_half": [int(len(A)), int(len(B))]}
+
+
+def en_from_embeddings(gts: list, semis: list, rng: np.random.Generator, *, lb_max_queries: int | None,
+                       Z_all: np.ndarray) -> dict:
+    """E_N for one arm from per-sample embeddings (PCA already fitted on real + generated together).
+    UB: per sample i a uniformly random partner j != i (real cells of both), Dif averaged over samples.
+    Dif_i: real vs generated of sample i. E_N = (mean_i Dif_i - LB) / (UB - LB) (eq. 18); per sample (Dif_i - LB) / (UB - LB)."""
+    P = len(gts)
+    lb = lower_bound(Z_all, rng, lb_max_queries)
+    partner = (np.arange(P) + rng.integers(1, P, size=P)) % P if P > 1 else np.zeros(P, int)
+    ub_i = [dif_sc(gts[i], gts[partner[i]]) for i in range(P)]
+    dif_i = [dif_sc(gts[i], semis[i]) for i in range(P)]
+    out = {"lb": lb, "partner": partner.tolist(), "per_sample": []}
+    for d in ("sq", "l2"):
+        ub = float(np.mean([u[d] for u in ub_i]))
+        dif = np.asarray([x[d] for x in dif_i])
+        out[d] = {"lb": lb[d], "ub": ub, "dif_mean": float(dif.mean()), "en": float((dif.mean() - lb[d]) / (ub - lb[d])),
+                  "en_i": ((dif - lb[d]) / (ub - lb[d])).tolist(), "dif_i": dif.tolist()}
+    return out
+
+
+def get_error_legacy(gts: list, semis: list, representatives: list, cluster_labels: list, n_comp: int = EN_PCS) -> dict:
+    """Line-by-line re-statement of scSemiProfiler utils.get_error for one round (global np.random state, sklearn PCA,
+    self-pairing allowed in the UB, representatives at LB, squared L2). Only for the equivalence test."""
+    from sklearn.decomposition import PCA
+    P = len(gts)
+    X = np.concatenate([np.concatenate(gts, 0), np.concatenate(semis, 0)], 0)
+    Xr = PCA(n_components=n_comp).fit_transform(X)
+    xg, xs, off = [], [], 0
+    for g in gts:
+        xg.append(Xr[off:off + len(g)])
+        off += len(g)
+    for s in semis:
+        xs.append(Xr[off:off + len(s)])
+        off += len(s)
+    lbgt = Xr.copy()
+    np.random.shuffle(lbgt)
+    h = lbgt.shape[0] // 2
+    a, b = lbgt[:h], lbgt[h:]
+    da, _ = sqdist_min(a, b)
+    db, _ = sqdist_min(b, a)
+    lb = float(np.r_[da, db].mean())
+    ubs = []
+    for i in range(P):
+        r = np.random.randint(0, P)
+        ubs.append(dif_sc(xg[i], xg[r])["sq"])
+    ub = float(np.mean(ubs))
+    semi = [lb if i in representatives else dif_sc(xg[i], xs[i])["sq"] for i in range(P)]
+    naive = [lb if i in representatives else dif_sc(xg[i], xg[representatives[cluster_labels[i]]])["sq"] for i in range(P)]
+    return {"upperbound": ub, "lowerbound": lb, "semierror": float(np.mean(semi)), "naiveerror": float(np.mean(naive)),
+            "en_semi": (float(np.mean(semi)) - lb) / (ub - lb)}
+
+
+# =========================================================================== unit inputs
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def free_gib(path: Path) -> float:
+    st = os.statvfs(path)
+    return st.f_bavail * st.f_frsize / 2**30
+
+
+def resolve_npz(path: Path, want_sha: str, fetch_root: Path, fetched: list) -> Path:
+    """The scored NPZ: the local file if present, else a sha-checked copy from server_2 (same path) under fetch_root,
+    with its receipt (.log) next to it so score_ft.open_arm can check output_sha256."""
+    path = Path(path)
+    if path.is_file():
+        return path
+    rel = path.relative_to(TASK)
+    dst = fetch_root / rel
+    marker = path.with_suffix(".moved")
+    if dst.is_file() and dst.with_suffix(".log").is_file():
+        if sha256(dst) == want_sha:
+            return dst
+        dst.unlink()
+    size = int(subprocess.run(["ssh", "-n", REMOTE, f"stat -c %s '{path}'"], capture_output=True, text=True,
+                              check=True).stdout.strip())
+    need = size / 2**30 + MIN_FREE_GIB
+    if free_gib(fetch_root) < need:
+        raise SystemExit(f"disk: {free_gib(fetch_root):.1f} GiB free < {need:.1f} GiB needed to fetch {path}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    log(f"fetching {rel} ({size / 2**30:.2f} GiB) from {REMOTE}")
+    subprocess.run(["rsync", "-a", "--bwlimit=200000", f"{REMOTE}:{path}", str(dst)], check=True)
+    rec = path.with_suffix(".log")
+    if rec.is_file():
+        shutil.copy2(rec, dst.with_suffix(".log"))
+    else:
+        subprocess.run(["rsync", "-a", f"{REMOTE}:{rec}", str(dst.with_suffix(".log"))], check=True)
+    fetched.append(dst)
+    got = sha256(dst)
+    if got != want_sha:
+        raise SystemExit(f"{dst}: sha {got[:12]} differs from the scored NPZ sha {want_sha[:12]}")
+    if marker.is_file():
+        txt = marker.read_text()
+        if f"sha {want_sha[:12]}" not in txt:
+            raise SystemExit(f"{marker}: marker sha differs ({txt.strip()})")
+    return dst
+
+
+def unit_calls(design: str, ds: str, draw: int | None) -> list[tuple[Path, tuple]]:
+    if design == "fewshot":
+        base = SCORES / ds / "fewshot_n5"
+        return [(base / f"draw{draw}", ("zs_raw", "zs_cal", "lora5", "zs_pseudo")), (base / f"draw{draw}_scsemi5", ("scsemi5",))]
+    if design == "pooled":
+        return [(SCORES / ds / "pooled", POOLED_ARMS)]
+    if design == "scored":
+        return [(SCORED["dir"], SCORED["arms"])]
+    raise ValueError(design)
+
+
+def unit_dir(design: str, ds: str, draw: int | None) -> Path:
+    if design == "scored":
+        return OUT_ROOT / ds / SCORED["unit"]
+    return OUT_ROOT / ds / (f"fewshot_n5/draw{draw}" if design == "fewshot" else "pooled")
+
+
+def observed_cells(spec, ref: dict, man: dict, donors: np.ndarray, cache: dict) -> tuple[list, dict]:
+    """All observed QC cells of the scored samples on the scoring genes (counts), per sample in the reference's
+    canonical cell order, from the same files the reference was built from (inputs sha-checked against
+    reference_manifest.json). cache: per dataset, reused by the draws of one process."""
+    if spec.name not in cache:
+        cache.clear()
+        cache[spec.name] = _observed_all(spec, ref, man)
+    X, srow, sid, inputs = cache[spec.name]
+    out = []
+    for d in donors:
+        out.append(X[np.flatnonzero(srow == int(np.flatnonzero(sid == d)[0]))].tocsr())
+    n = np.asarray([o.shape[0] for o in out])
+    ref_n = ref["n_cells"][[int(np.flatnonzero(ref["donors"].astype(str) == d)[0]) for d in donors]]
+    if not np.array_equal(n, ref_n):
+        raise SystemExit("observed cell counts per sample differ from the reference")
+    return out, {"inputs_sha256": inputs, "n_cells_total": int(n.sum())}
+
+
+def _observed_all(spec, ref: dict, man: dict):
+    feat = F.load_features(spec.features)
+    if feat["sha256"] != man["features"]["sha256"]:
+        raise SystemExit("features sha differs from the reference's")
+    gs = F.gene_sets(feat)
+    if not np.array_equal(gs["score_ids"], ref["score_ids"].astype(str)):
+        raise SystemExit("scoring genes differ from the reference")
+    cells = F.load_cells_datadir(spec, gs)
+    if cells is None or cells["inputs_sha256"] != man["cells"]["inputs_sha256"]:
+        raise SystemExit("observed cell files differ from the ones the reference was built from")
+    keys, _ = F.cell_keys(cells["table"].reset_index(drop=True))
+    srow = np.asarray(cells["sample_row"])
+    order = np.lexsort((keys, srow))          # the reference's canonical order (F.build_reference)
+    X = cells["X"].tocsr()[order][:, gs["score_idx"]].tocsr().astype(np.float32)
+    return X, srow[order], feat["sample_ids"], cells["inputs_sha256"]
+
+
+CODE_SHA256 = {str(p): sha256(p) for p in CODE_FILES}   # at import = the code this process runs
+
+
+# =========================================================================== one unit
+def pair_embeddings(v: dict, R: sp.csr_matrix, r_d: np.ndarray, Q: sp.csr_matrix, q_d: np.ndarray,
+                    zr_raw: np.ndarray | None = None) -> dict:
+    """Real set R and query set Q in the scorer's PCA-50: 'raw' = SB.project; 'dm' = score_ft.depth_matched's own
+    steps (SB.depth_match of the pair with a fresh rng(DEPTH_SEED), real set in the 'R1' slot, then SB.project),
+    returning the embeddings instead of only their precision/coverage. zr_raw: the view's fitted z1 for R = R1."""
+    names = v["donors"]
+    thinned, _ = F.SB.depth_match({"R1": R, "Q": Q}, {"R1": names[r_d], "Q": names[q_d]}, list(names),
+                                  np.random.default_rng(F.DEPTH_SEED))
+    return {"raw": (zr_raw if zr_raw is not None else F.SB.project(R, v["mean"], v["comps"]),
+                    F.SB.project(Q, v["mean"], v["comps"])),
+            "dm": (F.SB.project(thinned["R1"], v["mean"], v["comps"]), F.SB.project(thinned["Q"], v["mean"], v["comps"]))}
+
+
+def per_donor_pc(r1_d, q_d, S_, res) -> tuple:
+    nq, n1 = np.bincount(q_d, minlength=S_), np.bincount(r1_d, minlength=S_)
+    return (np.bincount(q_d, weights=res["inside"], minlength=S_) / nq,
+            np.bincount(r1_d, weights=res["covered"], minlength=S_) / n1)
+
+
+def score_set(name: str, v: dict, Q: sp.csr_matrix, q_d: np.ndarray, sigma_m: float, n_jobs: int,
+              expect: dict | None, oos: tuple | None) -> tuple[list, pd.DataFrame, dict]:
+    """Families 1, 2, 4 for one query set (an arm's P/C subsample, or R2), raw and depth matched, real side = R1
+    (the scorer's space). oos = (R2 counts, R2 donor index, set name): families 1-2 again with R2 as the real side."""
+    S_ = v["donors"].size
+    E = pair_embeddings(v, v["R1"], v["r1_d"], Q, q_d, zr_raw=v["z1"])
+    rows, per, chk = [], {"donor": v["donors"], "set": name}, {}
+    for mode, (zr, zg) in E.items():
+        t0 = time.monotonic()
+        m = {"set": name, "real_side": "R1", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        for k in KS:
+            # k = 10 raw: the view's own radii (score_ft.arm_metrics); every other k / mode: radii recomputed on zr
+            res = F.SB.precision_coverage(zr, v["radius"], zg) if (k == F.K_NN and mode == "raw") else pc_at_k(zr, zg, k)
+            m[f"precision_k{k}"], m[f"coverage_k{k}"], m[f"density_k{k}"] = res["precision"], res["coverage"], res["density"]
+            m[f"expected_coverage_identical_k{k}"] = expected_coverage(len(zr), len(zg), k)
+            pp, pc = per_donor_pc(v["r1_d"], q_d, S_, res)
+            per[f"precision_k{k}_{mode}"], per[f"coverage_k{k}_{mode}"] = pp, pc
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {name} [R1 {mode}] P/C k10 {m['precision_k10']:.4f}/{m['coverage_k10']:.4f} k5 {m['precision_k5']:.4f}/"
+            f"{m['coverage_k5']:.4f} k3 {m['precision_k3']:.4f}/{m['coverage_k3']:.4f} | AUC knn {m['c2st_knn_auc']:.3f} "
+            f"rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if oos is not None:
+        R2, r2_d, oname = oos
+        for mode, (zr, zg) in pair_embeddings(v, R2, r2_d, Q, q_d).items():
+            t0 = time.monotonic()
+            m = {"set": oname, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+            m.update(two_sample_block(zr, zg, sigma_m, n_jobs=n_jobs))
+            m["seconds"] = round(time.monotonic() - t0, 1)
+            rows.append(m)
+            log(f"  {oname} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN {m['nn1_acc']:.3f} "
+                f"| MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    if expect is not None:   # reproduction of the scorer's k = 10 values
+        for mode, key in (("raw", ""), ("dm", "_depth_matched")):
+            mm = next(r for r in rows if r["mode"] == mode)
+            for q in ("precision", "coverage"):
+                chk[f"{q}{key}"] = {"ours": mm[f"{q}_k10"], "scorer": expect[f"{q}{key}"],
+                                    "abs_diff": abs(mm[f"{q}_k10"] - expect[f"{q}{key}"])}
+                if "per_donor" in expect:
+                    d = np.abs(per[f"{q}_k10_{mode}"] - expect["per_donor"][f"{q}{key}"])
+                    chk[f"{q}{key}_per_donor_max_abs_diff"] = float(d.max())
+    return rows, pd.DataFrame(per), chk
+
+
+def run_unit(design: str, ds: str, draw: int | None, a) -> None:
+    t_unit = time.monotonic()
+    spec = F.DATASETS[ds]
+    out = unit_dir(design, ds, draw)
+    if (out / "manifest.json").is_file() and not a.force:
+        log(f"{out} done already")
+        return
+    out.mkdir(parents=True, exist_ok=True)
+    lock = out / ".in_progress"
+    if lock.is_file():   # another process (other stream) is computing this unit: skip unless its pid is gone
+        pid = int(lock.read_text().split()[0])
+        if Path(f"/proc/{pid}").exists():
+            log(f"{out} is being computed by pid {pid}; skipped")
+            return
+    lock.write_text(f"{os.getpid()} {F.now()}\n")
+    try:
+        _run_unit(design, ds, draw, a, t_unit, spec, out)
+    finally:
+        lock.unlink(missing_ok=True)
+
+
+def _run_unit(design: str, ds: str, draw: int | None, a, t_unit: float, spec, out: Path) -> None:
+    calls = unit_calls(design, ds, draw)
+    summ = {}
+    for cdir, arms in calls:
+        s = json.loads((cdir / "summary.json").read_text())
+        miss = [x for x in arms if x not in s["arms"]]
+        if miss:
+            raise SystemExit(f"{cdir}: arms {miss} not scored there")
+        summ[cdir] = s
+    first = summ[calls[0][0]]
+    donors = [str(x) for x in first["donors"]]
+    for cdir, s in summ.items():
+        if [str(x) for x in s["donors"]] != donors:
+            raise SystemExit(f"{cdir}: scored donors differ from {calls[0][0]}")
+        if s["reference"]["reference_sha256"] != first["reference"]["reference_sha256"]:
+            raise SystemExit(f"{cdir}: reference sha differs")
+    cache = F.CACHE_ROOT / ds
+    ref, man = F.load_reference(cache)
+    if man["reference_sha256"] != first["reference"]["reference_sha256"]:
+        raise SystemExit(f"{cache}: reference sha differs from the scored one")
+    log(f"{ds} {design} {'' if draw is None else f'draw{draw} '}: {len(donors)} scored samples; fitting the scorer's view")
+    v = S.make_view(ref, donors)
+    repro = {"unit": str(out), "pca": {"ours": v["pca"], "scorer": first["reference"]["pca"]},
+             "r2_control": {"ours": v["r2_control"], "scorer": first["reference"]["r2_control"]}, "arms": {}}
+    S_ = v["donors"].size
+    sigma_m = median_bandwidth(v["z1"])
+    log(f"bandwidth m (median pairwise distance of R1, PCA-50) = {sigma_m:.4f}")
+    rows, per_frames, en_rows, en_ps = [], [], [], []
+    fetched: list[Path] = []
+    fetch_root = Path(a.fetch_dir)
+
+    # ---------------- E_N inputs shared by all arms
+    rng_c = F.donor_rng
+    R1L = log1p_cp10k_sparse(v["R1"])
+    gram_r1 = Gram(R1L.shape[1]).add(R1L)
+    r1_split = [np.flatnonzero(v["r1_d"] == s) for s in range(S_)]
+    obs, obs_info = observed_cells(spec, ref, man, v["donors"], a.obs_cache)
+    # out-of-sample real sets from the scorer's donor-keyed permutation (F.reference_split): R1 = perm[:n],
+    # R2 = perm[n:2n] (both checked equal to reference.npz), R3 = perm[2n:3n] (fewer cells when the sample is small);
+    # the R2-vs-R3 control uses R2' = perm[n:n+m], m = min(n, |R3|), so both sides have the same size per sample.
+    r3_blocks, r2b_blocks, r3_d, r2b_d, oos_info = [], [], [], [], {"n_r3": [], "short_samples": []}
+    for k in range(S_):
+        nk, d = obs[k].shape[0], str(v["donors"][k])
+        a1, a2 = F.reference_split(nk, d)
+        if (obs[k][a1] != v["R1"][np.flatnonzero(v["r1_d"] == k)]).nnz or \
+                (obs[k][a2] != v["R2"][np.flatnonzero(v["r2_d"] == k)]).nnz:
+            raise SystemExit(f"{d}: R1 / R2 rebuilt from the observed cells differ from reference.npz")
+        perm = F.donor_rng(F.SUB_SEED, d).permutation(nk)
+        n = a1.size
+        r3 = np.sort(perm[2 * n:3 * n])
+        m_ = r3.size
+        if m_ < n:
+            oos_info["short_samples"].append({"sample": d, "n": int(n), "n_r3": int(m_)})
+        r3_blocks.append(obs[k][r3])
+        r2b_blocks.append(obs[k][np.sort(perm[n:n + m_])])
+        r3_d.append(np.full(m_, k))
+        r2b_d.append(np.full(m_, k))
+        oos_info["n_r3"].append(int(m_))
+    R3, R2b = sp.vstack(r3_blocks, format="csr"), sp.vstack(r2b_blocks, format="csr")
+    r3_d, r2b_d = np.concatenate(r3_d), np.concatenate(r2b_d)
+    log(f"observed cells: {obs_info['n_cells_total']} in {S_} samples; R1/R2 rebuilt = reference.npz; R3 {R3.shape[0]} "
+        f"cells ({len(oos_info['short_samples'])} samples with fewer than n)")
+    oos_r2 = (v["R2"], v["r2_d"])
+    if not a.no_en_all:
+        obsL = [log1p_cp10k_sparse(o) for o in obs]
+        gram_obs = Gram(R1L.shape[1])
+        for L in obsL:
+            gram_obs.add(L)
+    del obs
+
+    def en_unit(set_name: str, cellset: str, gts_L: list, semis_L: list, gram_real: Gram, n_rep_rows: int | None):
+        t0 = time.monotonic()
+        g = Gram(gts_L[0].shape[1])
+        for L in semis_L:
+            g.add(L)
+        mu, comps = (gram_real + g).pca(EN_PCS)
+        gts = [embed(L, mu, comps) for L in gts_L]
+        semis = [embed(L, mu, comps) for L in semis_L]
+        Z_all = np.vstack(gts + semis)
+        rng = np.random.default_rng([SEED, 17 if cellset == "pc" else 29])
+        res = en_from_embeddings(gts, semis, rng, Z_all=Z_all,
+                                 lb_max_queries=None if cellset == "pc" else EN_LB_MAX_QUERIES)
+        n_test = len(gts)
+        for d in ("sq", "l2"):
+            r = res[d]
+            en_rows.append({"set": set_name, "cellset": cellset, "distance": d, "n_samples": n_test,
+                            "n_cells_real": int(sum(len(x) for x in gts)), "n_cells_gen": int(sum(len(x) for x in semis)),
+                            "n_pcs": int(comps.shape[0]), "lb": r["lb"], "ub": r["ub"], "dif_mean": r["dif_mean"],
+                            "en": r["en"], "lb_exact": res["lb"]["exact"], "lb_queries": res["lb"]["n_queries"],
+                            "n_representative_rows": n_rep_rows,
+                            "en_reps_at_lb": (r["en"] * n_test / (n_test + n_rep_rows)) if n_rep_rows else None,
+                            "seconds": round(time.monotonic() - t0, 1)})
+            en_ps.append(pd.DataFrame({"set": set_name, "cellset": cellset, "distance": d, "donor": v["donors"],
+                                       "n_real": [len(x) for x in gts], "n_gen": [len(x) for x in semis],
+                                       "partner": v["donors"][res["partner"]], "dif": r["dif_i"], "en_i": r["en_i"]}))
+        log(f"  {set_name} E_N[{cellset}] sq {res['sq']['en']:.4f} (LB {res['sq']['lb']:.3f} UB {res['sq']['ub']:.3f} "
+            f"Dif {res['sq']['dif_mean']:.3f}) l2 {res['l2']['en']:.4f} ({round(time.monotonic() - t0, 1)} s)")
+
+    # ---------------- control: R1 vs R2 (the scorer's own)
+    expect_r2 = {"precision": first["reference"]["r2_control"]["precision"],
+                 "coverage": first["reference"]["r2_control"]["coverage"],
+                 "precision_depth_matched": first["reference"]["r2_control"]["depth_matched"]["precision"],
+                 "coverage_depth_matched": first["reference"]["r2_control"]["depth_matched"]["coverage"]}
+    r, p, chk = score_set(CONTROL, v, v["R2"], v["r2_d"], sigma_m, a.threads, expect_r2, oos=None)
+    rows += r
+    # out-of-sample control: R2' (real side) vs R3, families 1-2 only
+    for mode, (zr, zg) in pair_embeddings(v, R2b, r2b_d, R3, r3_d).items():
+        t0 = time.monotonic()
+        m = {"set": CONTROL_OOS, "real_side": "R2", "mode": mode, "n_real": int(len(zr)), "n_gen": int(len(zg))}
+        m.update(two_sample_block(zr, zg, sigma_m, n_jobs=a.threads))
+        m["seconds"] = round(time.monotonic() - t0, 1)
+        rows.append(m)
+        log(f"  {CONTROL_OOS} [R2 {mode}] AUC knn {m['c2st_knn_auc']:.3f} rf {m['c2st_rf_auc']:.3f} | 1-NN "
+            f"{m['nn1_acc']:.3f} | MMD2 {m['mmd2_bw1']:.4f} ({m['seconds']} s)")
+    per_frames.append(p)
+    repro["arms"][CONTROL] = chk
+    R2L = log1p_cp10k_sparse(v["R2"])
+    en_unit(CONTROL, "pc", [R1L[i] for i in r1_split], [R2L[np.flatnonzero(v["r2_d"] == s)] for s in range(S_)],
+            gram_r1, None)
+    if not a.no_en_all:
+        A_, B_ = [], []
+        for s in range(S_):
+            perm = rng_c(SEED, v["donors"][s]).permutation(obsL[s].shape[0])
+            h = obsL[s].shape[0] // 2
+            A_.append(obsL[s][np.sort(perm[:h])])
+            B_.append(obsL[s][np.sort(perm[h:])])
+        # the PCA basis is the one of all observed cells (A and B together): gram_real = A-part, semis add the B-part
+        gA = Gram(R1L.shape[1])
+        for L in A_:
+            gA.add(L)
+        en_unit(CONTROL, "all", A_, B_, gA, None)
+        del A_, B_
+
+    # ---------------- arms
+    pcache = a.pcache            # Poisson read-outs (scoring genes) by NPZ sha; zs_*_all are reused by later draws
+    n_rep_rows = None
+    if design == "fewshot":
+        dj = json.loads((TASK / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"][str(draw)]
+        n_rep_rows = int(dj["n_train_rows"])
+    panel_ids = ref["panel_ids"].astype(str)
+    for cdir, arms in calls:
+        s = summ[cdir]
+        per_csv = pd.read_csv(cdir / "per_donor.csv")
+        for name in arms:
+            t0 = time.monotonic()
+            pa = s["per_arm"][name]
+            path = resolve_npz(Path(pa["npz"]), pa["npz_sha256"], fetch_root, fetched)
+            arm = S.open_arm(name, path, panel_ids, allow_no_receipt=False)
+            if arm["sha256"] != pa["npz_sha256"] or not arm["receipt_verified"]:
+                raise SystemExit(f"{name}: NPZ sha / receipt check failed for {path}")
+            npos = {n: i for i, n in enumerate(arm["sample_ids"])}
+            rws = [np.flatnonzero(arm["bulk_index"] == npos[x]) for x in v["donors"]]
+            sel = np.concatenate(rws)
+            gen_d = np.repeat(np.arange(S_), [x.size for x in rws])
+            if arm["sha256"] not in pcache:
+                rates = np.ascontiguousarray(arm["d"]["generated_counts"], dtype=np.float32)
+                full = F.PR.poisson_integerise(rates, seed=F.POISSON_SEED, chunk_rows=4096)
+                del rates
+                pcache[arm["sha256"]] = full[:, ref["score_idx"]].tocsr()
+                del full
+            arm["d"].close()
+            Xg = pcache[arm["sha256"]][sel].tocsr()
+            sub = np.concatenate([np.flatnonzero(gen_d == k)[F.generated_subsample(int((gen_d == k).sum()),
+                                                                                    int(v["n_ref"][k]), v["donors"][k])]
+                                  for k in range(S_)])
+            Q, q_d = Xg[sub].tocsr(), gen_d[sub]
+            gc = pd.read_parquet(cdir / "arms" / name / "generated_cells.parquet", columns=["npz_row", "in_pc_subsample"])
+            same_rows = bool(np.array_equal(gc.npz_row.to_numpy(), sel)
+                             and np.array_equal(np.flatnonzero(gc.in_pc_subsample.to_numpy()), np.sort(sub)))
+            if not same_rows:
+                raise SystemExit(f"{name}: scored rows / P/C subsample differ from {cdir}/arms/{name}/generated_cells.parquet")
+            pdn = per_csv[per_csv.arm == name].set_index("donor").loc[v["donors"]]
+            h = s["headline"][name]
+            expect = {"precision": h["precision"], "coverage": h["coverage"], "precision_depth_matched": h["precision_dm"],
+                      "coverage_depth_matched": h["coverage_dm"],
+                      "per_donor": {k: pdn[k].to_numpy() for k in ("precision", "coverage", "precision_depth_matched",
+                                                                   "coverage_depth_matched")}}
+            log(f"{name}: {path.name} sha {arm['sha256'][:12]} (receipt verified), {sel.size} scored cells, "
+                f"{sub.size} in the P/C subsample (same rows as the scorer)")
+            r, p, chk = score_set(name, v, Q, q_d, sigma_m, a.threads, expect, oos=(oos_r2[0], oos_r2[1], name))
+            chk["rows_and_subsample_equal_scorer"] = same_rows
+            chk["npz"] = {"path": str(path), "scored_path": pa["npz"], "sha256": arm["sha256"]}
+            rows += r
+            per_frames.append(p)
+            repro["arms"][name] = chk
+            QL = log1p_cp10k_sparse(Q)
+            en_unit(name, "pc", [R1L[i] for i in r1_split], [QL[np.flatnonzero(q_d == k)] for k in range(S_)], gram_r1,
+                    n_rep_rows if name == "scsemi5" else None)
+            if not a.no_en_all:
+                XgL = log1p_cp10k_sparse(Xg)
+                en_unit(name, "all", obsL, [XgL[np.flatnonzero(gen_d == k)] for k in range(S_)], gram_obs,
+                        n_rep_rows if name == "scsemi5" else None)
+                del XgL
+            log(f"{name} done in {time.monotonic() - t0:.0f} s")
+            if not (design == "fewshot" and name in ("zs_raw", "zs_pseudo")):
+                pcache.pop(arm["sha256"], None)  # not reused by another unit
+    # ---------------- write
+    meta = {"dataset": ds, "design": design, "unit": "pooled" if draw is None else f"draw{draw}"}
+    if design == "scored":
+        meta["unit"] = SCORED["unit"]
+    met = pd.DataFrame(rows)
+    for k, x in reversed(list(meta.items())):
+        met.insert(0, k, x)
+    met.insert(3, "label", met["set"].map(ARM_LABEL))
+    met.to_csv(out / "metrics.csv", index=False)
+    perd = pd.concat(per_frames, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        perd.insert(0, k, x)
+    perd.to_csv(out / "per_donor.csv", index=False)
+    en = pd.DataFrame(en_rows)
+    for k, x in reversed(list(meta.items())):
+        en.insert(0, k, x)
+    en.to_csv(out / "en.csv", index=False)
+    ep = pd.concat(en_ps, ignore_index=True)
+    for k, x in reversed(list(meta.items())):
+        ep.insert(0, k, x)
+    ep.to_csv(out / "en_per_sample.csv", index=False)
+    worst = max([c.get("abs_diff", 0.0) for arm in repro["arms"].values() for c in arm.values() if isinstance(c, dict)]
+                + [0.0])
+    repro["max_abs_diff_k10_pooled"] = worst
+    repro["oos_r3"] = oos_info
+    repro["pca_equal"] = repro["pca"]["ours"] == repro["pca"]["scorer"]
+    (out / "repro.json").write_text(json.dumps(repro, indent=1, default=float) + "\n")
+    code = CODE_SHA256   # hashed when the process started
+    manifest = {"schema": "paired_ft_extra_metrics.v1", **meta, "written_utc": F.now(), "command": sys.argv,
+                "threads": a.threads, "donors": list(map(str, v["donors"])), "n_samples": int(S_),
+                "calls": {str(c): {"arms": list(arms), "summary_sha256": sha256(c / "summary.json")} for c, arms in calls},
+                "reference_sha256": man["reference_sha256"], "bandwidth_m": sigma_m,
+                "params": {"seed": SEED, "ks": KS, "knn_c2st_k": KNN_C2ST_K, "rf_trees": RF_TREES, "cv_folds": CV_FOLDS,
+                           "bw_multiples": BW_MULTIPLES, "bw_max_cells": BW_MAX_CELLS, "en_pcs": EN_PCS,
+                           "en_lb_max_queries_all_cells": EN_LB_MAX_QUERIES, "en_all_cells": not a.no_en_all},
+                "n_representative_rows": n_rep_rows, "fetched_from_server2": [str(f) for f in fetched],
+                "code_sha256": code, "seconds": round(time.monotonic() - t_unit, 1),
+                "max_abs_diff_k10_pooled": worst}
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=1, default=float) + "\n")
+    log(f"unit {meta['unit']} of {ds} written to {out} in {manifest['seconds']} s (k=10 max |diff| vs scorer {worst:.2e})")
+    for f in fetched:
+        if f.name.startswith("zs__raw_all") or f.name.startswith("zs__pseudo_all"):
+            continue  # shared by the draws of the cohort; removed by main after the last draw
+        f.unlink(missing_ok=True)
+        f.with_suffix(".log").unlink(missing_ok=True)
+        log(f"removed fetched copy {f}")
+
+
+# =========================================================================== collect
+def collect() -> None:
+    """Tables and concatenated CSVs: tools/collect_extra_metrics.py (pandas only)."""
+    import collect_extra_metrics as C
+    C.main()
+
+
+def parse(argv=None):
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--design", choices=["fewshot", "pooled", "scored"])
+    p.add_argument("--score-dir", default=None, help="--design scored: a score_ft.py output dir (summary.json)")
+    p.add_argument("--arms", default=None, help="--design scored: comma list of arms scored in --score-dir")
+    p.add_argument("--unit", default=None, help="--design scored: output sub-path under scores_extra/<dataset>/ "
+                                                "(e.g. scsemi_cv_20261002/pooled)")
+    p.add_argument("--dataset", choices=DATASETS)
+    p.add_argument("--draws", default="0,1,2,3,4")
+    p.add_argument("--threads", type=int, default=7)
+    p.add_argument("--fetch-dir", default=None, help="where server_2 NPZ copies go (default: scratch under scores_extra)")
+    p.add_argument("--no-en-all", action="store_true", help="skip the all-cells E_N (P/C-cell E_N is always computed)")
+    p.add_argument("--force", action="store_true", help="recompute units that already have a manifest")
+    p.add_argument("--collect", action="store_true")
+    return p.parse_args(argv)
+
+
+def main(argv=None) -> int:
+    a = parse(argv)
+    if a.collect:
+        collect()
+        return 0
+    if not (1 <= a.threads <= 8):
+        raise SystemExit("--threads must be 1..8")
+    try:
+        from threadpoolctl import threadpool_limits
+        threadpool_limits(a.threads)
+    except ImportError:
+        pass
+    if a.design is None or a.dataset is None:
+        raise SystemExit("--design and --dataset are required (or --collect)")
+    a.fetch_dir = a.fetch_dir or str(OUT_ROOT / "_fetch_tmp")
+    Path(a.fetch_dir).mkdir(parents=True, exist_ok=True)
+    a.pcache, a.obs_cache = {}, {}
+    if a.design == "scored":
+        if not (a.score_dir and a.arms and a.unit):
+            raise SystemExit("--design scored needs --score-dir, --arms and --unit")
+        unit = Path(a.unit)
+        if unit.is_absolute() or ".." in unit.parts or unit.parts[0] in ("pooled", "fewshot_n5"):
+            raise SystemExit("--unit must be a new relative sub-path (not pooled/ or fewshot_n5/)")
+        SCORED.update({"dir": Path(a.score_dir).resolve(), "arms": tuple(x for x in a.arms.split(",") if x),
+                       "unit": str(unit)})
+        run_unit("scored", a.dataset, None, a)
+    elif a.design == "pooled":
+        run_unit("pooled", a.dataset, None, a)
+    else:
+        for j in [int(x) for x in a.draws.split(",") if x.strip()]:
+            run_unit("fewshot", a.dataset, j, a)
+        shared = Path(a.fetch_dir) / "generated" / a.dataset / "fewshot_n5"
+        for f in list(shared.glob("zs__*_all.npz")) if shared.is_dir() else []:
+            f.unlink(missing_ok=True)
+            f.with_suffix(".log").unlink(missing_ok=True)
+            log(f"removed fetched copy {f}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/tools/finalize_scsemi_cv_budget.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Post-run scoring of the 2026-10-02 scSemiProfiler runs (CPU only; run on the host that holds every fold NPZ of the arms;
+# modelled on finalize_rankcal.sh, same tools, nothing existing is re-scored, re-pooled or overwritten):
+#   cv     : scSemiProfiler 5-fold CV (representatives = LoRA real_lora train + inner-val rows)   arm scsemi__raw
+#            compare with real_lora__raw in scores/<ds>/{fold<k>,pooled}/ (same donors)
+#   budget : scSemiProfiler equal pair budget (representatives = lora_n<n> train + inner-val rows), n in {5,10,20,40}
+#            arms scsemi_n<n>__raw; compare with lora_n<n>__raw in scores/<ds>/{fold<k>,pooled}/ (immicro, ye2026_sepsis)
+# Steps: per fold, score the arms -> scores/<ds>/<sub>/fold<k>/ (score_arms.sh: same scorer, contrast arguments and
+#        CPU unit as score_fold.sh; same donors as scores/<ds>/fold<k>/);
+#        pool the five folds -> generated/<ds>/pooled_<sub>/ (pool_folds.py --arms --out: nothing existing re-pooled;
+#        the broadcast condition of an __raw arm is the folds' test_raw.npz);
+#        score all donors -> scores/<ds>/<sub>/pooled/ (same donors as scores/<ds>/pooled/; with a contrast, e.g. sepsis,
+#        score_ft.py also writes the top-50 DEG score, i.e. the metrics of scores/<ds>/pooled_deg/).
+# Already-scored output dirs are skipped, so a rerun resumes.  <sub> = scsemi_cv_20261002 | scsemi_budget_20261002.
+# usage: finalize_scsemi_cv_budget.sh DATASET cv|budget
+set -uo pipefail
+T=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+ds=${1:?usage: finalize_scsemi_cv_budget.sh DATASET cv|budget}; exp=${2:?usage: finalize_scsemi_cv_budget.sh DATASET cv|budget}
+case $exp in
+  cv)     sub=scsemi_cv_20261002; arms=(scsemi__raw) ;;
+  budget) sub=scsemi_budget_20261002; arms=(scsemi_n5__raw scsemi_n10__raw scsemi_n20__raw scsemi_n40__raw)
+          [[ $ds == immicro || $ds == ye2026_sepsis ]] || { echo "budget arms exist for immicro and ye2026_sepsis only" >&2; exit 2; } ;;
+  *) echo "usage: finalize_scsemi_cv_budget.sh DATASET cv|budget" >&2; exit 2 ;;
+esac
+G=$T/generated/$ds; S=$T/scores/$ds/$sub
+missing=0
+for f in 0 1 2 3 4; do
+  for a in "${arms[@]}"; do
+    [[ -s $G/fold$f/$a.npz ]] || { echo "not here: $G/fold$f/$a.npz$([[ -f $G/fold$f/$a.moved ]] && echo ' (moved)')"; missing=1; }
+    v=$G/fold$f/$a.validation.json
+    [[ -s $v ]] && python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "$v" \
+      || { echo "no passing validation: $v"; missing=1; }
+  done
+done
+(( missing == 0 )) || { echo "ABORT: every fold NPZ of $ds/$exp must be here and validated ($(hostname -s))" >&2; exit 1; }
+n_fail=0
+for f in 0 1 2 3 4; do
+  bash "$T/tools/score_arms.sh" "$ds" "$G/fold$f" "$S/fold$f" "score-$ds-$sub-f$f" "${arms[@]}" || { n_fail=$((n_fail+1)); echo "score $ds $exp fold $f failed"; }
+done
+P=$G/pooled_$sub
+csv=$(IFS=,; echo "${arms[*]}")
+if [[ -s $P/POOL_MANIFEST.json ]]; then echo "$P pooled already"
+else
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 56 )); do sleep 120; done
+  bash "$T/tools/run_unit.sh" "pool-$ds-$sub" 4 "$PY" "$T/tools/pool_folds.py" "$ds" --arms "$csv" --out "$P" \
+    || { echo "pool $ds $exp failed"; exit 1; }
+fi
+bash "$T/tools/score_arms.sh" "$ds" "$P" "$S/pooled" "score-$ds-$sub-pooled" "${arms[@]}" || { n_fail=$((n_fail+1)); echo "pooled score failed"; }
+echo "finalize_scsemi_cv_budget $ds $exp done $(date -Is) failed=$n_fail -> $S"
+(( n_fail == 0 ))