Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/SOURCE_MAP.json

@@ -0,0 +1,167 @@
+[
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/campaign.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/0/campaign.py",
+    "sha256": "c0ed2ddf6ab13f4af1cd6bc785e52037a3e814b0af60965a0fef74d0d971adec"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/runtime.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/1/runtime.py",
+    "sha256": "67ea571aa077aa1d17131a9d5ade3eadc8c310620d8a358be81d3f69e065a7aa"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/support_input_isolation.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/2/support_input_isolation.py",
+    "sha256": "762f5f7bbf908c478544b0c5c05a8fbf6c3bf63eff6a2d7af88105473c1c20a2"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tools/two_host_resume.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/3/two_host_resume.py",
+    "sha256": "606b8de898959dc371904c2f1facde4974ebdf792412fcbe6b5ee1db9904cbd1"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_campaign.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/4/test_campaign.py",
+    "sha256": "ab621bcc280e50a9e3ca1feab4643fcd3658bba53ff7d7c133cc36bda692ba4b"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_runtime.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/5/test_runtime.py",
+    "sha256": "66523fc94de255d13066fa85c4aabb1efa26304060d0de5f11205e55c8f041d0"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_runtime_recovery.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/6/test_runtime_recovery.py",
+    "sha256": "fe6d4ee7facac1221d948675dcf024434b75f948575add930e5638b888ea78e9"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_support_input_isolation.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/7/test_support_input_isolation.py",
+    "sha256": "483a022a2de95d975f1546f9c7d3fcc049a5d6ef205815ba0a8b4772580dc6f3"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/tests/test_two_host_resume.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/8/test_two_host_resume.py",
+    "sha256": "b5b64587d36add74e79c9fdb8df4c185fa111d78a1b8a70ef712ee5dc919974e"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/rebind_sources_20261012.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/9/rebind_sources_20261012.py",
+    "sha256": "8125a9ef88ef56e89462f816666d83b93bd68452df534a8074271beaed34a1a7"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/SOURCE_REUSE.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/10/SOURCE_REUSE.json",
+    "sha256": "5c0f005f2fb8afe0369a2fa06b1f3a21b89bd2566ccd7ad6d1844b29e2ac8359"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/two_host/REMOTE_SOURCE_VERIFICATION.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/11/REMOTE_SOURCE_VERIFICATION.json",
+    "sha256": "9ef066e91a5a39dcff0b43ced1431a9c6be07ddcdadacb15d2b4dabbc42e581a"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/two_host/STAGED_SOURCE_VERIFICATION.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/12/STAGED_SOURCE_VERIFICATION.json",
+    "sha256": "3a5da9716560c7e6b2181c36df9f57f919f7e54f3ab1c8761d08e376e5dc879a"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/two_host/config.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/13/config.json",
+    "sha256": "56c62625359d63a2944984a4f60fd4b4b1aabc621826b1105f09be0e06a5fdd9"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/two_host/execution_map_server2.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/14/execution_map_server2.json",
+    "sha256": "1da78d904304463648215f7014539d0c56c1f4c302a36a642eedcff3b0460b2c"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/20261012T141153Z-manual-reboot/RECOVERY.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/15/RECOVERY.json",
+    "sha256": "bceb2f1f6a12ad9387565266c313de87b56681d598ea34e398867ed3c3ced2b4"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/16/ft_sdd.py",
+    "sha256": "9333b296acfb58e52ebe10e30c3334250bf2ce8c3dbfd446d65726f6b8da4abb"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi/tools/prepare_draw_inputs.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/17/prepare_draw_inputs.py",
+    "sha256": "debff837167b4fd9e5fea4c14beb1c4c56cb3baf476150b08396a3eee421d02a"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-train-proof.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/18/immicro-healthy-fold1-n5-train-proof.json",
+    "sha256": "abc5c91549a18877b3dc9569d67aad489310c4c618c83f4e7dc8f337566e042e"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-train-proof.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/19/immicro-healthy-fold0-n5-train-proof.json",
+    "sha256": "32fad796b963affb2e3fcdf1248f22804b0c595678305846477c02e47636c16c"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-train.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/20/immicro-healthy-fold1-n5-train.json",
+    "sha256": "752d2bf7c1ed36ee224cf8d4ec4a5c36f3ec3258fc0d044c377d151886403b48"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-scinputs-proof.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/21/immicro-healthy-fold0-n5-scinputs-proof.json",
+    "sha256": "678c157b9f907b853276212437b95854bc5dfee5a58a29096c8df4c8d0bbb8ca"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-train.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/22/immicro-healthy-fold0-n5-train.json",
+    "sha256": "a5adc14fe5a2bce4f9aaaaae6a3cfa087e13f91ba8bf7972eb937f1508cf3714"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-scinputs-proof.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/23/immicro-healthy-fold1-n5-scinputs-proof.json",
+    "sha256": "482e5417167f4f67b0bc00d4ed1cc1972fa4602757b700767cd1d881485e89e0"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold1-n5-scinputs.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/24/immicro-healthy-fold1-n5-scinputs.json",
+    "sha256": "feeeef8b6e7a120c879344084e58b646f2c590b693895dba0313d0fadb5cd278"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/recoveries/source_reuse_20261012/immicro-healthy-fold0-n5-scinputs.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/25/immicro-healthy-fold0-n5-scinputs.json",
+    "sha256": "2888679e086cfd188852113c98c28fba592220a109223c78fba5cf56392a3b8c"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold0/n5/REPLAY.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/26/REPLAY.json",
+    "sha256": "bdb8576d6558943f4886c3fe063445a129a4c2c04a3adb8d11bfb869f04c8c82"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n5/REPLAY.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/27/REPLAY.json",
+    "sha256": "baa4653814d2a151ab0f55830e57b4a6a30d47edcecebaefb727c968cb495609"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold0/n5/ISOLATION.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/28/ISOLATION.json",
+    "sha256": "aa3e1cafad1d953458a459522aa2395b673e864caa8829bc514db04b272b831c"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/isolated/immicro/healthy/fold1/n5/ISOLATION.json",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/29/ISOLATION.json",
+    "sha256": "0a50a995963f589387a27142c14cc2933c216899e89f794f8bd1e47bff1334db"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/backups/recovery_input_isolation_20261012T142024Z/plans/paper_figures_strictpairs_20261012/tools/support_input_isolation.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/30/support_input_isolation.py",
+    "sha256": "1e383c79085c6d20afd839b401ec2e321df3d535d3d1b5552ba9f0e59ba033af"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/backups/recovery_input_isolation_20261012T142024Z/plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/31/ft_sdd.py",
+    "sha256": "e7f3d38b65932ffe99292a8841a15eb9e7cce205afec1de6b34b59a06731b82d"
+  },
+  {
+    "original": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/backups/recovery_input_isolation_20261012T142024Z/plans/paired_finetune_intradataset_20260927/scsemi/tools/prepare_draw_inputs.py",
+    "snapshot": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/32/prepare_draw_inputs.py",
+    "sha256": "b11b9f206a04fdac99dc489a8387647f0a334a59d5761a0c1bd964301933da8f"
+  }
+]

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/32/prepare_draw_inputs.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+"""Build scSemiProfiler inputs for one paired split (CPU only).
+
+Representatives = every usable row of the split's training donors (paired sc + real bulk).
+Targets        = the split's test rows (real bulk only; their cells are never read here).
+
+  --mode fewshot --draw j : training donors = data/<ds>/fewshot_n5/draw<j>/train_donors.txt,
+                            targets = draw<j>/test_samples.txt, condition = draw<j>/test_raw.npz
+  --mode cv --fold k      : training donors = every usable donor not in fold k (inner-val donors included),
+                            targets = fold k's rows, condition = data/<ds>/fold<k>/test_raw.npz
+  --mode budget --fold k --n N   (added 2026-10-02): representatives = exactly the rows LoRA lora_n<N> of fold k saw,
+                            runs/<ds>/fold<k>/lora_n<N>/RUN.json train_rows + inner_val_rows (checked against
+                            data/<ds>/CAL_BUDGET.json fit_sample_ids when present); targets = fold k's rows (checked
+                            against the run's test_rows_never_loaded_for_training); condition = fold<k>/test_raw.npz.
+                            The manifest also records target_donors (used by run_scsemi_paired.py --reuse-from).
+  --check-only            (added 2026-10-02): build and check everything (split, genes, cells, depth, condition), write
+                            nothing under --work; print the summary (and the representative / target lists to
+                            --check-out if given).  Without it the builder behaves exactly as before.
+
+Modeled genes = final 6k panel genes measured in the bulk of every representative and target row AND in the
+single cells of every representative row (features.npz bulk_valid / sc_valid).  No target single-cell mask,
+depth or cell count enters.
+
+Writes <work>/inputs/:
+  bulk.h5ad        raw bulk counts (float64) of reps + targets on the modeled genes, obs['sample_ids'],
+                   rows in features.npz order; upstream initsetup(normed=False) library-normalises + log1p's it
+  rep_sc.h5ad      raw UMI counts (float32 CSR) of every representative cell on the modeled genes,
+                   obs['sample_ids'] = the representative row's sample id; upstream scprocess(normed=False)
+  inputs_manifest.json   rows, genes, depth rule, source hashes
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+
+TASK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927")
+HERE = TASK / "scsemi"
+sys.path.insert(0, str(TASK / "tools"))
+import prepare_dataset as PD  # noqa: E402  (the benchmark's own loader: bulk_raw with unmeasured NaN -> 0, masks, use)
+
+SEED = 20260927
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def split_rows(ds: str, mode: str, j: int, sample_ids: np.ndarray, folds: pd.DataFrame,
+               n: int | None = None, support_manifest: Path | None = None) -> dict:
+    data = TASK / "data" / ds
+    usable = folds["fold"].to_numpy() >= 0
+    donors = folds["donor_id"].astype(str).to_numpy()
+    extra = {}
+    if support_manifest is not None:
+        strict_tools = TASK.parents[1] / "plans/paper_figures_strictpairs_20261012/tools"
+        sys.path.insert(0, str(strict_tools))
+        from support_manifest import load_manifest, select_rows
+        m = load_manifest(support_manifest, folds)
+        if m["cohort"] != ds:
+            raise SystemExit("support cohort differs from dataset")
+        rep, tgt = select_rows(m, folds)
+        rel = support_manifest.resolve().parent.relative_to(
+            TASK.parents[1] / "plans/paper_figures_strictpairs_20261012/protocol/splits")
+        cond = TASK.parents[1] / "plans/paper_figures_strictpairs_20261012/data" / rel / "test_raw.npz"
+        return {"rep": rep, "tgt": tgt, "train_donors": m["train_donor_ids"],
+                "test": m["test_sample_ids"], "condition": cond,
+                "sources": {"support.json": support_manifest},
+                "support_sha256": m["sha256"], "target_donors": m["test_donor_ids"]}
+    if mode == "fewshot":
+        dd = data / "fewshot_n5" / f"draw{j}"
+        train_donors = [x.strip() for x in (dd / "train_donors.txt").read_text().splitlines() if x.strip()]
+        test = [x.strip() for x in (dd / "test_samples.txt").read_text().splitlines() if x.strip()]
+        cond = dd / "test_raw.npz"
+        sources = {"train_donors.txt": dd / "train_donors.txt", "test_samples.txt": dd / "test_samples.txt"}
+        rep = np.flatnonzero(np.isin(donors, train_donors) & usable)
+    elif mode == "cv":
+        fold = folds["fold"].to_numpy()
+        test = sample_ids[fold == j].tolist()
+        rep = np.flatnonzero(usable & (fold != j))
+        train_donors = sorted(set(donors[rep]))
+        cond = data / f"fold{j}" / "test_raw.npz"
+        sources = {}
+    elif mode == "budget":
+        fold = folds["fold"].to_numpy()
+        rj = TASK / "runs" / ds / f"fold{j}" / f"lora_n{n}" / "RUN.json"
+        run = json.loads(rj.read_text())
+        if run["fold"] != j or (run.get("train_subset") or {}).get("train_n") != n:
+            raise SystemExit(f"{rj}: not the fold {j} n={n} learning-curve run")
+        fit = list(run["train_rows"]) + list(run["inner_val_rows"])
+        test = sample_ids[fold == j].tolist()
+        if sorted(run["test_rows_never_loaded_for_training"]) != sorted(test):
+            raise SystemExit(f"{rj}: its test rows differ from fold {j}'s rows")
+        pos = {s: i for i, s in enumerate(sample_ids)}
+        if len(set(fit)) != len(fit) or any(s not in pos for s in fit):
+            raise SystemExit(f"{rj}: duplicate or unknown fit rows")
+        rep = np.asarray(sorted(pos[s] for s in fit), dtype=np.int64)
+        if not (usable[rep] & (fold[rep] != j)).all():
+            raise SystemExit(f"{rj}: a fit row is unusable or in fold {j}")
+        cb = data / "CAL_BUDGET.json"
+        if cb.exists():
+            e = json.loads(cb.read_text())["folds"][str(j)]["n"][str(n)]
+            if sorted(e["fit_sample_ids"]) != sorted(fit) or e["lora_checkpoint_sha256"] != run["checkpoint_sha256"]:
+                raise SystemExit(f"{cb}: fold {j} n={n} fit rows / LoRA checkpoint differ from {rj}")
+        train_donors = sorted(set(donors[rep]))
+        cond = data / f"fold{j}" / "test_raw.npz"
+        sources = {"lora_RUN.json": rj, **({"CAL_BUDGET.json": cb} if cb.exists() else {})}
+        extra = {"budget": {"n": int(n), "fold": int(j), "lora_run": str(rj), "lora_checkpoint_sha256": run["checkpoint_sha256"],
+                            "n_train_rows": len(run["train_rows"]), "n_inner_val_rows": len(run["inner_val_rows"]),
+                            "train_rows": list(run["train_rows"]), "inner_val_rows": list(run["inner_val_rows"])}}
+    else:
+        raise SystemExit(f"unknown mode {mode}")
+    pos = {s: i for i, s in enumerate(sample_ids)}
+    miss = [s for s in test if s not in pos]
+    if miss:
+        raise SystemExit(f"test samples not in features.npz: {miss[:5]}")
+    tgt = np.asarray([pos[s] for s in test], dtype=np.int64)
+    if not usable[tgt].all():
+        raise SystemExit("a test row is not usable (fold -1)")
+    if set(donors[rep]) & set(donors[tgt]):
+        raise SystemExit("a donor is both representative and target")
+    if len(set(test)) != len(test):
+        raise SystemExit("duplicate test samples")
+    return {"rep": rep, "tgt": tgt, "train_donors": train_donors, "test": test, "condition": cond, "sources": sources,
+            **extra}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--dataset", required=True)
+    ap.add_argument("--mode", choices=["fewshot", "cv", "budget"], default="fewshot")
+    ap.add_argument("--draw", type=int, help="fewshot draw index")
+    ap.add_argument("--fold", type=int, help="cv / budget fold index")
+    ap.add_argument("--n", type=int, help="budget: the LoRA learning-curve n (runs/<ds>/fold<k>/lora_n<n>)")
+    ap.add_argument("--work", type=Path, required=True)
+    ap.add_argument("--smoke-reps", type=int, default=0, help="SMOKE ONLY: keep the first N representative rows")
+    ap.add_argument("--smoke-cells", type=int, default=0, help="SMOKE ONLY: at most N cells per representative")
+    ap.add_argument("--smoke-targets", default="", help="SMOKE ONLY: comma list of target sample ids")
+    ap.add_argument("--smoke-rep-ids", default="", help="SMOKE ONLY: comma list of representative sample ids to keep")
+    ap.add_argument("--check-only", action="store_true", help="dry run: check everything, write nothing under --work")
+    ap.add_argument("--check-out", type=Path, default=None, help="--check-only: write the split summary JSON here")
+    ap.add_argument("--support-manifest", type=Path, default=None,
+                    help="strict support.json; representatives are its exact n sample IDs")
+    a = ap.parse_args(argv)
+    if a.support_manifest is not None:
+        if a.draw is not None or a.fold is not None or a.n is not None:
+            raise SystemExit("--support-manifest cannot be combined with --draw/--fold/--n")
+        a.mode = "strict"
+        j = 0
+    else:
+        j = a.draw if a.mode == "fewshot" else a.fold
+    if j is None:
+        raise SystemExit("--draw (fewshot) or --fold (cv, budget) required")
+    if (a.mode == "budget") != (a.n is not None):
+        raise SystemExit("--n is required with --mode budget and only valid there")
+    smoke = bool(a.smoke_reps or a.smoke_cells or a.smoke_targets or a.smoke_rep_ids)
+    if a.support_manifest is not None and smoke:
+        raise SystemExit("strict support forbids smoke subsetting")
+    work = a.work.resolve()
+    if smoke and "/scsemi/smoke/" not in str(work) + "/":
+        raise SystemExit("smoke subsetting only under scsemi/smoke/")
+    out = work / "inputs"
+    if not a.check_only:
+        if (out / "inputs_manifest.json").exists():
+            raise SystemExit(f"{out}/inputs_manifest.json exists; inputs are immutable (preserve and inspect)")
+        out.mkdir(parents=True, exist_ok=True)
+    data = TASK / "data" / a.dataset
+    d = PD.load(data)
+    folds = pd.read_csv(data / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), d["sample_ids"]):
+        raise SystemExit("folds.csv rows differ from features.npz")
+    s = split_rows(a.dataset, a.mode, j, d["sample_ids"], folds, n=a.n,
+                   support_manifest=a.support_manifest)
+    rep, tgt = s["rep"], s["tgt"]
+    if a.smoke_rep_ids:
+        keep_r = set(a.smoke_rep_ids.split(","))
+        rep = np.asarray([r for r in rep if d["sample_ids"][r] in keep_r], dtype=np.int64)
+    if a.smoke_reps:
+        rep = rep[: a.smoke_reps]
+    if a.smoke_targets:
+        keep = set(a.smoke_targets.split(","))
+        tgt = np.asarray([t for t in tgt if d["sample_ids"][t] in keep], dtype=np.int64)
+        s["test"] = [x for x in s["test"] if x in keep]
+    if a.mode == "fewshot" and not smoke:
+        usable = np.flatnonzero(folds["fold"].to_numpy() >= 0)
+        if set(rep.tolist()) | set(tgt.tolist()) != set(usable.tolist()):
+            raise SystemExit("representatives + targets do not cover the usable rows")
+    # modeled genes
+    z = np.load(data / "cells_panel6k.npz", allow_pickle=False)
+    panel = z["panel_gene_ids"].astype(str)
+    gpos = {g: i for i, g in enumerate(d["gene_ids"])}
+    pcanon = np.asarray([gpos[g] for g in panel], dtype=np.int64)
+    rows = np.sort(np.concatenate([rep, tgt]))
+    bulk_ok = d["bulk_valid"][rows][:, pcanon].all(0)
+    sc_ok = d["sc_valid"][rep][:, pcanon].all(0)
+    model_pidx = np.flatnonzero(bulk_ok & sc_ok)
+    genes = panel[model_pidx]
+    if genes.size < 1000:
+        raise SystemExit(f"only {genes.size} modeled genes")
+    # scorer's scoring genes (all rows of the dataset) for the record
+    score_mask = d["bulk_valid"][:, pcanon].all(0) & d["sc_valid"][:, pcanon].all(0)
+    # bulk
+    import anndata as ad
+    B = d["bulk"][rows][:, pcanon[model_pidx]].astype(np.float64)
+    if not np.isfinite(B).all() or (B < 0).any():
+        raise SystemExit("non-finite or negative bulk on the modeled genes")
+    if (B.sum(1) <= 0).any():
+        raise SystemExit("a bulk row has no counts on the modeled genes")
+    sym = pd.read_csv(TASK.parents[1] / "artifacts/panel_ladder_floor01_1m_20260923/tiers/6k/selected_genes.csv")
+    sym = sym.set_index("gene_id").gene_symbol.astype(str)
+    var = pd.DataFrame({"gene_symbol": sym.reindex(genes).to_numpy()}, index=pd.Index(genes, name="gene_id"))
+    obs_b = pd.DataFrame({"sample_ids": d["sample_ids"][rows], "donor_id": d["donor_ids"][rows],
+                          "group": d["groups"][rows], "role": np.where(np.isin(rows, rep), "representative", "target")},
+                         index=pd.Index(d["sample_ids"][rows], name="obs"))
+    if not a.check_only:
+        ad.AnnData(X=B, obs=obs_b, var=var).write_h5ad(out / "bulk.h5ad")
+    # representative cells
+    X = sp.csr_matrix((z["data"], z["indices"], z["indptr"]), shape=tuple(int(x) for x in z["shape"]))
+    rs = np.asarray(z["row_sample"], dtype=np.int64)
+    blocks, obs_rows, per_rep = [], [], []
+    rng = np.random.default_rng(SEED)
+    for r in rep:
+        cells = np.flatnonzero(rs == r)
+        if a.smoke_cells and cells.size > a.smoke_cells:
+            cells = np.sort(rng.choice(cells, a.smoke_cells, replace=False))
+        Xr = X[cells][:, model_pidx].tocsr().astype(np.float32)
+        lib = np.asarray(Xr.sum(1)).ravel()
+        if (lib <= 0).any():
+            raise SystemExit(f"{d['sample_ids'][r]}: {int((lib <= 0).sum())} cells without counts on the modeled genes")
+        blocks.append(Xr)
+        obs_rows.append(pd.DataFrame({"sample_ids": d["sample_ids"][r], "donor_id": d["donor_ids"][r],
+                                      "source_cell_row": cells}))
+        per_rep.append({"sample_id": str(d["sample_ids"][r]), "donor_id": str(d["donor_ids"][r]),
+                        "group": str(d["groups"][r]), "n_cells": int(cells.size),
+                        "median_umi_modeled_genes": float(np.median(lib))})
+    Xs = sp.vstack(blocks, format="csr")
+    obs_s = pd.concat(obs_rows, ignore_index=True)
+    obs_s.index = pd.Index([f"{a_}|{b_}" for a_, b_ in zip(obs_s.sample_ids, obs_s.source_cell_row)], name="cell")
+    if not a.check_only:
+        ad.AnnData(X=Xs, obs=obs_s, var=var.copy()).write_h5ad(out / "rep_sc.h5ad")
+    lib_all = np.asarray(Xs.sum(1)).ravel()
+    depth = float(np.median(lib_all))
+    cond = s["condition"]
+    man = {
+        "schema": "scsemi_paired.inputs.v1", "written_utc": datetime.now(timezone.utc).isoformat(),
+        "dataset": a.dataset, "mode": a.mode, "split": j, "smoke": smoke,
+        "smoke_settings": {"reps": a.smoke_reps, "cells": a.smoke_cells, "targets": a.smoke_targets,
+                           "rep_ids": a.smoke_rep_ids} if smoke else None,
+        "train_donors": s["train_donors"],
+        "representatives": per_rep, "targets": [str(x) for x in d["sample_ids"][tgt]],
+        "target_order_test_samples": s["test"],
+        "bulk_row_order": [str(x) for x in d["sample_ids"][rows]],
+        "n_representatives": int(rep.size), "n_targets": int(tgt.size), "n_rep_cells": int(Xs.shape[0]),
+        "modeled_genes": {"n": int(genes.size), "gene_ids": genes.tolist(), "panel_index": model_pidx.tolist(),
+                          "rule": "6k panel genes with bulk_valid in every rep+target row and sc_valid in every rep row",
+                          "equals_scorer_scoring_genes": bool(np.array_equal(model_pidx, np.flatnonzero(score_mask))),
+                          "n_scorer_scoring_genes": int(score_mask.sum())},
+        "depth": {"value": depth, "rule": "median over all representative cells (all rows of the training donors) of the "
+                  "per-cell UMI sum on the modeled genes; every generated cell is scaled to this expected library",
+                  "n_cells": int(lib_all.size)},
+        "condition_npz": str(cond), "condition_sha256": sha(cond),
+        "sources": {"features.npz": sha(data / "features.npz"), "folds.csv": sha(data / "folds.csv"),
+                    "cells_panel6k.npz": sha(data / "cells_panel6k.npz"),
+                    **{k: sha(v) for k, v in s["sources"].items()}},
+        "files": ({"bulk.h5ad": sha(out / "bulk.h5ad"), "rep_sc.h5ad": sha(out / "rep_sc.h5ad")}
+                  if not a.check_only else None),
+        "builder_sha256": sha(Path(__file__)),
+    }
+    if a.mode == "strict":
+        man["support_sha256"] = s["support_sha256"]
+        man["target_donors"] = s["target_donors"]
+    if a.mode == "budget":
+        man["target_donors"] = sorted({str(x) for x in d["donor_ids"][tgt]})
+        man["budget"] = s["budget"]
+    with np.load(cond, allow_pickle=False) as cz:
+        cond_ids = cz["sample_ids"].astype(str).tolist()
+    if not smoke and sorted(cond_ids) != sorted(man["targets"]):
+        raise SystemExit("condition NPZ sample_ids differ from the targets")
+    man["condition_sample_order"] = cond_ids
+    if a.check_only:
+        summary = {"dataset": a.dataset, "mode": a.mode, "split": j, "n": a.n, "work": str(work),
+                   "reps": [r["sample_id"] for r in per_rep], "targets": man["targets"],
+                   "rep_cells": {r["sample_id"]: r["n_cells"] for r in per_rep}, "n_rep_cells": int(Xs.shape[0]),
+                   "modeled_genes": int(genes.size), "modeled_panel_index": model_pidx.tolist(),
+                   "equals_scorer_genes": man["modeled_genes"]["equals_scorer_scoring_genes"],
+                   "depth": depth, "condition_npz": str(cond), "condition_matches_targets": True,
+                   "train_donors": s["train_donors"], **({"budget": s["budget"]} if a.mode == "budget" else {})}
+        if a.check_out is not None:
+            a.check_out.parent.mkdir(parents=True, exist_ok=True)
+            a.check_out.write_text(json.dumps(summary, indent=1) + "\n")
+        print(json.dumps({k: summary[k] for k in ("dataset", "mode", "split", "n", "n_rep_cells", "modeled_genes",
+                                                  "equals_scorer_genes", "depth")} | {"reps": len(summary["reps"]),
+                                                                                       "targets": len(summary["targets"])}))
+        return 0
+    tmp = out / "inputs_manifest.json.tmp"
+    tmp.write_text(json.dumps(man, indent=1) + "\n")
+    tmp.replace(out / "inputs_manifest.json")
+    print(json.dumps({"dataset": a.dataset, "mode": a.mode, "split": j, "reps": int(rep.size), "targets": int(tgt.size),
+                      "rep_cells": int(Xs.shape[0]), "modeled_genes": int(genes.size),
+                      "equals_scorer_genes": man["modeled_genes"]["equals_scorer_scoring_genes"], "depth": depth}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/archive_queue/ARCHIVE_RECOVERY_QUEUE.json

@@ -0,0 +1,14 @@
+{
+  "first_existing_update": "20261012T130738Z-strictpairs-implementation",
+  "first_service": "pbisc-strict-archive-instrumented-resume-20261012.service",
+  "updates": [
+    {
+      "id": "20261012T131501Z-strictpairs-final-caption",
+      "request": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T131501Z-strictpairs-final-caption/request.json"
+    },
+    {
+      "id": "20261012T143729Z-strictpairs-recovery-two-host",
+      "request": "/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/request.json"
+    }
+  ]
+}

paper-releases/pbisc-diffusion/updates/20261012T143729Z-strictpairs-recovery-two-host/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T143729Z-strictpairs-recovery-two-host/snapshot/archive_queue/finish_recovery_archives.py

@@ -0,0 +1,60 @@
+"""Finish the explicitly approved archive queue once; no publish retry loop."""
+import json
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+from runtime import atomic_json, sha256, stamp
+
+RELEASE = Path('/home/sj_server_1/PBISC/paper-release-20260928')
+PYTHON = '/home/sj_server_1/miniforge3/bin/python'
+CLI = RELEASE / 'maintenance/update.py'
+STATE = ROOT / 'recoveries/ARCHIVE_RECOVERY_STATUS.json'
+
+
+def verified(identifier):
+    folder = RELEASE / 'maintenance/updates' / identifier
+    receipt = folder / 'UPDATE_VERIFIED.json'
+    status = folder / 'STATUS.json'
+    return receipt.is_file() and status.is_file() and json.loads(status.read_text()).get('phase') == 'verified'
+
+
+def main():
+    queue = json.loads((ROOT / 'recoveries/ARCHIVE_RECOVERY_QUEUE.json').read_text())
+    state = {'state': 'waiting_existing_publisher', 'started_at': stamp(), 'completed': []}
+    atomic_json(STATE, state)
+    try:
+        while not verified(queue['first_existing_update']):
+            active = subprocess.run(['systemctl', '--user', 'is-active', '--quiet', queue['first_service']])
+            if active.returncode:
+                raise RuntimeError('existing archive resume stopped without verification; inspect diagnostics')
+            time.sleep(15)
+        for update in queue['updates']:
+            state.update(state='publishing', active=update['id'], updated_at=stamp())
+            atomic_json(STATE, state)
+            if not verified(update['id']):
+                folder = RELEASE / 'maintenance/updates' / update['id']
+                if not (folder / 'manifest.json').is_file():
+                    subprocess.run([PYTHON, str(CLI), 'prepare', '--request', update['request'], '--id', update['id']], check=True)
+                subprocess.run([PYTHON, str(CLI), 'publish', update['id'], '--execute'], check=True)
+            if not verified(update['id']):
+                raise RuntimeError('publisher returned without a verified receipt')
+            state['completed'].append(update['id'])
+        latest = json.loads((RELEASE / 'LATEST.json').read_text())
+        last = queue['updates'][-1]['id']
+        receipt = RELEASE / 'maintenance/updates' / last / 'UPDATE_VERIFIED.json'
+        if latest['id'] != last or latest['verified_receipt_sha256'] != sha256(receipt):
+            raise RuntimeError('archive latest pointer does not match recovery receipt')
+        state.update(state='completed', active=None, updated_at=stamp(), latest_id=last)
+        atomic_json(STATE, state)
+    except BaseException as exc:
+        state.update(state='failed_needs_inspection', error=str(exc), updated_at=stamp())
+        atomic_json(STATE, state)
+        raise
+
+
+if __name__ == '__main__':
+    main()