Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/import_scsemi_legacy.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+"""Audit and adopt old exact-five-pair sepsis scSemi work without relabelling its origin.
+
+`prepare` builds strict CPU inputs and n-only prepared assets. `verify` is read-only.
+`adopt` hardlinks verified legacy evidence under the strict work's adopted_legacy/
+directory and writes an explicit source-bound receipt. It does not create a
+native strict run_manifest, checkpoint receipt, or scorer-ready generated arm.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+
+PLAN = Path(__file__).resolve().parents[1]
+OLD = PLAN.parent / "paired_finetune_intradataset_20260927"
+SC_PY = PLAN.parent / "immicro_scsemi_comparison_20260927/runtime_env/bin/python"
+BUILDER = OLD / "scsemi/tools/prepare_draw_inputs.py"
+WRAPPER = PLAN / "tools/run_scsemi_strict.py"
+EXPORTER_OLD = OLD / "scsemi/tools/export_npz.py.bak_20261002"
+EXCLUDE_PREPARED = {"status/init_representatives.txt", "status/init_cluster_labels.txt"}
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 22), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def read(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def paths(support_path: Path) -> tuple[dict, Path, Path, Path]:
+    support_path = support_path.resolve()
+    support = read(support_path)
+    cohort, unit = support.get("cohort"), support.get("unit")
+    if cohort != "ye2026_sepsis" or not re.fullmatch(r"draw[0-4]_n5", str(unit)):
+        raise ValueError("legacy import is limited to five sepsis disease draws")
+    draw = unit.removesuffix("_n5")
+    canonical = PLAN / "protocol/splits" / cohort / "disease" / draw / "support.json"
+    if support_path != canonical.resolve():
+        raise ValueError("noncanonical strict support path")
+    sys.path.insert(0, str(PLAN / "tools"))
+    from support_manifest import load_manifest
+    import pandas as pd
+    support = load_manifest(support_path, pd.read_csv(OLD / "data" / cohort / "folds.csv"))
+    old = OLD / "scsemi/work" / cohort / "fewshot_n5" / draw
+    new = PLAN / "scsemi" / cohort / "disease" / draw
+    generated = OLD / "generated" / cohort / "fewshot_n5" / draw / "scsemi5__raw.npz"
+    return support, old, new, generated
+
+
+def preflight() -> None:
+    active = subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"],
+                            check=True, capture_output=True, text=True)
+    if active.stdout.strip() != "active":
+        raise RuntimeError("ml-memory-guard.service inactive")
+    subprocess.run(["/home/sj_server_1/.local/libexec/ml-memory-guard", "--check"], check=True)
+    apps = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory", "--format=csv,noheader"],
+                          check=True, capture_output=True, text=True)
+    # CPU preparation is bounded to two threads and observed <5 GiB on draw0;
+    # a small active CUDA job is compatible if global headroom remains ample.
+    mem = next(int(x.split()[1]) for x in Path("/proc/meminfo").read_text().splitlines() if x.startswith("MemAvailable:"))
+    if mem < 48 * 1024 * 1024:
+        raise RuntimeError("less than 48 GiB MemAvailable")
+
+
+def prepare(support_path: Path) -> Path:
+    support, _, work, _ = paths(support_path)
+    preflight()
+    env = {**os.environ, "CUDA_VISIBLE_DEVICES": "", "OMP_NUM_THREADS": "2", "OPENBLAS_NUM_THREADS": "2"}
+    args = [str(SC_PY), "-u", str(BUILDER), "--dataset", support["cohort"],
+            "--support-manifest", str(support_path), "--work", str(work)]
+    if not (work / "inputs/inputs_manifest.json").exists():
+        subprocess.run(args, check=True, env=env)
+    if not (work / "prepared.json").exists():
+        subprocess.run([str(SC_PY), "-u", str(WRAPPER), "--support-manifest", str(support_path),
+                        "--work", str(work), "--phase", "prepare", "--device", "cpu", "--threads", "2",
+                        "--lean-hvset"], check=True, env=env)
+    return work
+
+
+def _assert_file(path: Path, expected: str) -> None:
+    if not path.is_file() or sha(path) != expected:
+        raise ValueError(f"file absent or hash mismatch: {path}")
+
+
+def _same_rep_cells(old: Path, new: Path) -> None:
+    try:
+        import anndata as ad
+    except ImportError:
+        subprocess.run([str(SC_PY), str(Path(__file__)), "--internal-compare", str(old), str(new)], check=True)
+        return
+    a = ad.read_h5ad(old / "inputs/rep_sc.h5ad")
+    b = ad.read_h5ad(new / "inputs/rep_sc.h5ad")
+    if not a.obs_names.is_unique or not b.obs_names.is_unique or set(a.obs_names) != set(b.obs_names):
+        raise ValueError("representative cell identities differ")
+    if not a.var_names.equals(b.var_names):
+        raise ValueError("representative gene axis differs")
+    b = b[a.obs_names].copy()
+    if not a.obs.equals(b.obs) or not a.var.equals(b.var) or (a.X != b.X).nnz:
+        raise ValueError("representative observed cells differ after ID alignment")
+
+
+def verify(support_path: Path) -> dict:
+    """Read-only full source/equivalence audit; fail before any adoption write."""
+    s, old, new, generated = paths(support_path)
+    oi, ni = read(old / "inputs/inputs_manifest.json"), read(new / "inputs/inputs_manifest.json")
+    op, np_ = read(old / "prepared.json"), read(new / "prepared.json")
+    orun, nrun = read(old / "run_manifest.json"), read(new / "run_manifest.json")
+    status = read(old / "status.json")
+    receipt = read(generated.with_suffix(".log"))
+    if oi.get("mode") != "fewshot" or ni.get("mode") != "strict" or oi.get("smoke") or ni.get("smoke"):
+        raise ValueError("source or target is not a complete full five-pair run")
+    if any("reuse" in key.lower() for record in (oi, op, orun) for key in record):
+        raise ValueError("legacy scSemi reused another run's HVG or checkpoints")
+    old_reps = [x["sample_id"] for x in oi["representatives"]]
+    new_reps = [x["sample_id"] for x in ni["representatives"]]
+    if set(old_reps) != set(new_reps) or new_reps != s["train_sample_ids"] or len(new_reps) != 5:
+        raise ValueError("five own representative IDs differ")
+    if oi["targets"] != ni["targets"] or ni["targets"] != s["test_sample_ids"]:
+        raise ValueError("target IDs/order differ")
+    if oi["train_donors"] != ni["train_donors"] or ni["train_donors"] != s["train_donor_ids"]:
+        raise ValueError("training donor identities differ")
+    if ni.get("support_sha256") != s["sha256"] or ni["sources"].get("support.json") != sha(support_path):
+        raise ValueError("strict target input has no exact support binding")
+    for key in ("n_representatives", "n_targets", "n_rep_cells", "modeled_genes", "depth",
+                "bulk_row_order", "targets", "condition_sample_order"):
+        if oi[key] != ni[key]:
+            raise ValueError(f"legacy/strict input mismatch: {key}")
+    if oi["condition_sha256"] != ni["condition_sha256"]:
+        raise ValueError("real bulk raw condition differs")
+    if oi["sources"]["features.npz"] != ni["sources"]["features.npz"] or \
+            oi["sources"]["folds.csv"] != ni["sources"]["folds.csv"] or \
+            oi["sources"]["cells_panel6k.npz"] != ni["sources"]["cells_panel6k.npz"]:
+        raise ValueError("base data sources differ")
+    for root, m in ((old, oi), (new, ni)):
+        for f, digest in m["files"].items():
+            _assert_file(root / "inputs" / f, digest)
+    if oi["files"]["bulk.h5ad"] != ni["files"]["bulk.h5ad"]:
+        raise ValueError("bulk input bytes differ")
+    _same_rep_cells(old, new)
+    old_protocol = {k: v for k, v in orun["protocol"].items() if k != "hvset_impl"}
+    new_protocol = {k: v for k, v in nrun["protocol"].items() if k != "hvset_impl"}
+    if old_protocol != new_protocol or orun["protocol"].get("hvset_impl") is not None or \
+            not str(nrun["protocol"].get("hvset_impl", "")).startswith("tools/lean_hvset."):
+        raise ValueError("scSemi method protocol differs")
+    source_provenance = {"old_initial_source": orun["source"], "strict_source": nrun["source"],
+                         "approved_migration": None}
+    if orun["source"] != nrun["source"]:
+        migrations = orun.get("migrations", [])
+        allowed = read(OLD / "scsemi/compat_migrations.json")["transitions"]
+        allowed_ids = {x["id"] for x in allowed}
+        witness = next((m for m in migrations if m.get("to_binding", {}).get("source") == nrun["source"]
+                        and "source" in m.get("changed", []) and
+                        set(m.get("transitions", [])) <= allowed_ids and
+                        "trailing_size1_batch_20260928" in m.get("transitions", [])), None)
+        if witness is None:
+            raise ValueError("old/new vendor source differs without an approved recorded migration")
+        source_provenance["approved_migration"] = witness
+    for k in ("environment", "lean_cellgraph_sha256", "geneset_mapped_gmt_sha256"):
+        if orun[k] != nrun[k]:
+            raise ValueError(f"scSemi source/environment differs: {k}")
+    if orun["protocol"]["seeds"]["base"] != 20260927:
+        raise ValueError("old scSemi seed rule differs")
+    if set(op["files"]) != set(np_["files"]):
+        raise ValueError("prepared asset lists differ")
+    missing_cleaned_source = []
+    cleanup_script = OLD / "scsemi/tools/run_queue_scsemi.sh"
+    cleanup_text = cleanup_script.read_text()
+    for f, digest in op["files"].items():
+        source_file = old / "scsemi_project" / f
+        if f.startswith("sample_sc/") and not source_file.exists():
+            if 'removed sample_sc/*.h5ad (sha256 kept in prepared.json)' not in cleanup_text:
+                raise ValueError("source representative cells absent without documented cleanup")
+            missing_cleaned_source.append(f)
+        else:
+            _assert_file(source_file, digest)
+    for f, digest in np_["files"].items():
+        _assert_file(new / "scsemi_project" / f, digest)
+    for f in sorted(set(op["files"]) - EXCLUDE_PREPARED):
+        if op["files"][f] != np_["files"][f]:
+            raise ValueError(f"n-only prepared/pretraining input differs: {f}")
+    if op["files"]["hvset.npy"] != np_["files"]["hvset.npy"]:
+        raise ValueError("n-only HVG differs")
+    if (not status["pretrain_complete"] or not status["infer_complete"] or status["n_reps"] != 5 or
+            status["n_targets"] != len(s["test_sample_ids"]) or status["targets_done"] != len(s["test_sample_ids"])):
+        raise ValueError("legacy inference incomplete")
+    if op["run_signature"] != orun["run_signature"] or status["run_signature"] != orun["run_signature"]:
+        raise ValueError("legacy work signature inconsistent")
+    model_hashes = {}
+    order = oi["bulk_row_order"]
+    for rep in old_reps:
+        for stage, stem in ((1, "fast_reconst1_"), (2, "fastreconst2_")):
+            file = old / "scsemi_project/models" / f"{stem}{rep}"
+            rec_path = file.with_name(file.name + ".receipt.json")
+            rec = read(rec_path)
+            expected_seed = 20260927 + stage * 1000 + order.index(rep)
+            if (not rec.get("complete") or rec["run_signature"] != orun["run_signature"] or
+                    rec["representative"] != rep or rec["stage"] != stage or rec["seed"] != expected_seed):
+                raise ValueError(f"checkpoint receipt/source mismatch: {file}")
+            _assert_file(file, rec["sha256"])
+            model_hashes[file.name] = rec["sha256"]
+    shard_hashes = {}
+    for target in s["test_sample_ids"]:
+        file = old / "shards" / f"{target}.npz"
+        rec = read(old / "shards" / f"{target}.json")
+        if (not rec.get("complete") or rec["sample_id"] != target or
+                rec["run_signature"] != orun["run_signature"] or
+                rec["representative"] not in old_reps or
+                rec["target_bulk_index"] != order.index(target) or
+                rec["seed"] != 20260927 + order.index(target) or
+                not rec.get("lossless_csr_verified")):
+            raise ValueError(f"target shard receipt/source mismatch: {target}")
+        _assert_file(file, rec["shard_sha256"])
+        shard_hashes[target] = rec["shard_sha256"]
+    if receipt["run_signature"] != orun["run_signature"] or receipt["condition_sha256"] != ni["condition_sha256"]:
+        raise ValueError("old generated output receipt differs from exact strict raw condition")
+    if receipt["exporter_sha256"] != sha(EXPORTER_OLD):
+        raise ValueError("archived source exporter bytes differ from output receipt")
+    _assert_file(generated, receipt["output_sha256"])
+    with np.load(generated, allow_pickle=False) as z:
+        samples = z["sample_ids"].astype(str).tolist()
+        meta = json.loads(str(z["metadata_json"]))
+        if samples != s["test_sample_ids"] or z["cells_per_bulk"].tolist() != [1500] * len(samples):
+            raise ValueError("old generated sample/cell budget differs")
+        if meta["mode"] != "fewshot" or set(meta["representatives"]) != set(new_reps):
+            raise ValueError("old generated metadata does not name exact five representatives")
+    return {"schema": "pbisc.scsemi.legacy-adoption-proof.v1", "status": "verified_source_not_native_strict_run",
+            "cohort": s["cohort"], "unit": s["unit"], "support_sha256": s["sha256"],
+            "source_work": str(old), "strict_work": str(new), "source_generated": str(generated),
+            "source_generated_sha256": receipt["output_sha256"],
+            "source_generated_receipt_sha256": sha(generated.with_suffix(".log")),
+            "source_run_signature": orun["run_signature"], "strict_prepared_run_signature": nrun["run_signature"],
+            "source_provenance": source_provenance,
+            "source_manifest_sha256": {"inputs": sha(old / "inputs/inputs_manifest.json"),
+                                       "prepared": sha(old / "prepared.json"), "run": sha(old / "run_manifest.json")},
+            "strict_manifest_sha256": {"inputs": sha(new / "inputs/inputs_manifest.json"),
+                                       "prepared": sha(new / "prepared.json"), "run": sha(new / "run_manifest.json")},
+            "prepared_assets_equal": sorted(set(op["files"]) - EXCLUDE_PREPARED),
+            "initial_selection_status_excluded": sorted(EXCLUDE_PREPARED),
+            "source_sample_sc_cleaned_after_training": missing_cleaned_source,
+            "source_cleanup_script_sha256": sha(cleanup_script) if missing_cleaned_source else None,
+            "model_sha256": model_hashes, "target_shard_sha256": shard_hashes,
+            "scientific_equivalence": "same exact five representatives and target samples, same raw bulk condition, modeled genes, depth, cell counts after identity alignment, n-only HVG and all pretraining assets, protocol/seed and verified source model/shard/output receipts",
+            "provenance_limit": "legacy work was run as fewshot, not as a native strict-support run; source signature and old metadata remain unchanged"}
+
+
+def adopt(support_path: Path) -> dict:
+    proof = verify(support_path)
+    source = Path(proof["source_work"])
+    new = Path(proof["strict_work"])
+    generated = Path(proof["source_generated"])
+    dest = new / "adopted_legacy"
+    dest.mkdir(parents=True, exist_ok=True)
+    links = [(generated, dest / generated.name),
+             (generated.with_suffix(".log"), dest / generated.with_suffix(".log").name)]
+    for name in ("inputs/inputs_manifest.json", "prepared.json", "run_manifest.json", "status.json"):
+        links.append((source / name, dest / name))
+    for name in proof["prepared_assets_equal"]:
+        if name not in proof["source_sample_sc_cleaned_after_training"]:
+            links.append((source / "scsemi_project" / name, dest / "scsemi_project" / name))
+    for name in proof["model_sha256"]:
+        file = source / "scsemi_project/models" / name
+        links.extend([(file, dest / "scsemi_project/models" / name),
+                      (file.with_name(name + ".receipt.json"), dest / "scsemi_project/models" / (name + ".receipt.json"))])
+    for target in proof["target_shard_sha256"]:
+        for suffix in ("npz", "json"):
+            links.append((source / "shards" / f"{target}.{suffix}", dest / "shards" / f"{target}.{suffix}"))
+    for src, target in links:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists():
+            if not target.is_file() or sha(target) != sha(src):
+                raise ValueError(f"existing adoption evidence differs: {target}")
+        else:
+            os.link(src, target)
+    proof["adopted_evidence_dir"] = str(dest)
+    proof["linked_files"] = len(links)
+    path = dest / "ADOPTION.json"
+    if path.exists():
+        if read(path) != proof:
+            raise ValueError("existing adoption receipt differs from current verified source")
+    else:
+        path.write_text(json.dumps(proof, indent=2) + "\n")
+    return proof
+
+
+def export_adopted(support_path: Path) -> dict:
+    """Publish bit-identical old cells with a truthful adoption receipt; validate all shards."""
+    preflight()
+    proof = verify(support_path)
+    source = Path(proof["source_generated"])
+    old = Path(proof["source_work"])
+    new = Path(proof["strict_work"])
+    adoption_path = new / "adopted_legacy/ADOPTION.json"
+    if not adoption_path.is_file():
+        raise ValueError("source not adopted into strict work")
+    adopted = read(adoption_path)
+    for key, value in proof.items():
+        if adopted.get(key) != value:
+            raise ValueError(f"adoption receipt/source changed: {key}")
+    if adopted.get("adopted_evidence_dir") != str(adoption_path.parent) or adopted.get("linked_files", 0) < 1:
+        raise ValueError("adoption evidence incomplete")
+    adopted_source = adoption_path.parent / source.name
+    if not adopted_source.is_file() or not os.path.samefile(source, adopted_source):
+        raise ValueError("adopted generated source hardlink differs")
+    draw = proof["unit"].removesuffix("_n5")
+    out = PLAN / "generated" / proof["cohort"] / "disease" / draw / "scsemi.npz"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    if out.exists():
+        if not os.path.samefile(out, adopted_source):
+            raise ValueError("canonical strict arm already exists with different source")
+    else:
+        os.link(adopted_source, out)
+    strict_condition = PLAN / "data" / proof["cohort"] / "disease" / draw / "test_raw.npz"
+    old_log = read(source.with_suffix(".log"))
+    if sha(strict_condition) != old_log["condition_sha256"]:
+        raise ValueError("strict raw condition no longer equals legacy generation condition")
+    receipt = {"schema": "pbisc.scsemi.adopted-output.v1", "output": str(out),
+               "output_sha256": proof["source_generated_sha256"],
+               "support_sha256": proof["support_sha256"],
+               "condition_npz": str(strict_condition), "condition_sha256": old_log["condition_sha256"],
+               "source_condition_npz": old_log["condition_npz"],
+               "source_output": str(source), "source_output_sha256": proof["source_generated_sha256"],
+               "source_receipt_sha256": proof["source_generated_receipt_sha256"],
+               "source_work": str(old), "strict_prepared_work": str(new),
+               "adoption_receipt": str(adoption_path), "adoption_receipt_sha256": sha(adoption_path),
+               "run_signature": proof["source_run_signature"],
+               "provenance": "hardlink of legacy fewshot output; no native strict GPU training or inference claimed"}
+    log_path = out.with_suffix(".log")
+    if log_path.exists():
+        if read(log_path) != receipt:
+            raise ValueError("existing adopted output receipt differs")
+    else:
+        log_path.write_text(json.dumps(receipt, indent=2) + "\n")
+    # Legacy independent validator recomputes each exported cell from the old,
+    # sha-checked shard and verifies the original metadata's real bulk source.
+    env = {**os.environ, "CUDA_VISIBLE_DEVICES": "", "OMP_NUM_THREADS": "2", "OPENBLAS_NUM_THREADS": "2"}
+    subprocess.run([str(SC_PY), str(OLD / "scsemi/tools/validate_export.py"),
+                    "--work", str(old), "--npz", str(out)], check=True, env=env)
+    validation = read(out.with_suffix(".validation.json"))
+    if validation.get("passed") is not True or validation.get("npz_sha256") != receipt["output_sha256"]:
+        raise ValueError("legacy independent shard-level export validation failed")
+    return {"schema": "pbisc.scsemi.adopted-output-status.v1", "status": "validated_legacy_adoption",
+            "support_sha256": proof["support_sha256"], "output": str(out),
+            "output_sha256": receipt["output_sha256"], "adoption_receipt": str(adoption_path),
+            "validation": str(out.with_suffix(".validation.json")),
+            "validation_sha256": sha(out.with_suffix(".validation.json"))}
+
+
+def validate_adopted_generation(path: Path, support: dict) -> dict:
+    """Scorer binding for verified legacy sepsis output; never relabel native training."""
+    cohort, unit = support.get("cohort"), support.get("unit")
+    if cohort != "ye2026_sepsis" or not re.fullmatch(r"draw[0-4]_n5", str(unit)):
+        raise ValueError("adopted scSemi is limited to exact-five sepsis draws")
+    draw = unit.removesuffix("_n5")
+    canonical_support = PLAN / "protocol/splits" / cohort / "disease" / draw / "support.json"
+    s, old, strict_work, source = paths(canonical_support)
+    if s["sha256"] != support.get("sha256") or s["train_sample_ids"] != support.get("train_sample_ids") or \
+            s["test_sample_ids"] != support.get("test_sample_ids"):
+        raise ValueError("adoption support differs from canonical strict support")
+    expected = PLAN / "generated" / cohort / "disease" / draw / "scsemi.npz"
+    path = Path(path).resolve()
+    if path != expected.resolve() or not path.is_file() or not os.path.samefile(path, source):
+        raise ValueError("canonical adopted output is absent or no longer the source hardlink")
+    proof = verify(canonical_support)
+    adoption_path = strict_work / "adopted_legacy/ADOPTION.json"
+    adoption = read(adoption_path)
+    for key, value in proof.items():
+        if adoption.get(key) != value:
+            raise ValueError(f"adoption source proof differs: {key}")
+    if adoption.get("adopted_evidence_dir") != str(adoption_path.parent) or adoption.get("linked_files", 0) < 1:
+        raise ValueError("adoption receipt has no linked evidence")
+    receipt_path = path.with_suffix(".log")
+    receipt = read(receipt_path)
+    strict_condition = PLAN / "data" / cohort / "disease" / draw / "test_raw.npz"
+    source_receipt = read(source.with_suffix(".log"))
+    expected_fields = {"schema": "pbisc.scsemi.adopted-output.v1", "output": str(path),
+                       "output_sha256": proof["source_generated_sha256"],
+                       "support_sha256": s["sha256"], "condition_npz": str(strict_condition),
+                       "condition_sha256": source_receipt["condition_sha256"],
+                       "source_condition_npz": source_receipt["condition_npz"],
+                       "source_output": str(source),
+                       "source_output_sha256": proof["source_generated_sha256"],
+                       "source_receipt_sha256": proof["source_generated_receipt_sha256"],
+                       "source_work": str(old), "strict_prepared_work": str(strict_work),
+                       "adoption_receipt": str(adoption_path), "adoption_receipt_sha256": sha(adoption_path),
+                       "run_signature": proof["source_run_signature"]}
+    if any(receipt.get(k) != v for k, v in expected_fields.items()):
+        raise ValueError("adopted output receipt differs from source and strict support")
+    if sha(path) != receipt["output_sha256"] or sha(strict_condition) != receipt["condition_sha256"]:
+        raise ValueError("adopted cells or strict raw condition changed")
+    validation_path = path.with_suffix(".validation.json")
+    validation = read(validation_path)
+    if (validation.get("passed") is not True or validation.get("npz") != str(path) or
+            validation.get("npz_sha256") != receipt["output_sha256"] or
+            validation.get("targets") != len(s["test_sample_ids"]) or
+            validation.get("cells") != 1500 * len(s["test_sample_ids"]) or
+            validation.get("modeled_genes") != 5975):
+        raise ValueError("independent legacy shard-level validation absent or mismatched")
+    with np.load(path, allow_pickle=False) as z:
+        if z["sample_ids"].astype(str).tolist() != s["test_sample_ids"]:
+            raise ValueError("adopted output has extra or missing test samples")
+        metadata = json.loads(str(z["metadata_json"]))
+    old_inputs = read(old / "inputs/inputs_manifest.json")
+    if (metadata.get("work") != str(old) or metadata.get("mode") != "fewshot" or
+            metadata.get("arm") != "scsemi5" or metadata.get("run_signature") != proof["source_run_signature"] or
+            metadata.get("input_condition_path") != source_receipt["condition_npz"] or
+            metadata.get("input_condition_sha256") != source_receipt["condition_sha256"] or
+            set(metadata.get("representatives", [])) != set(s["train_sample_ids"]) or
+            metadata.get("seed") != 20260927 or metadata.get("unit") != "expected_counts (Poisson rates)" or
+            metadata.get("n_modeled_genes") != old_inputs["modeled_genes"]["n"] or
+            source_receipt.get("seed") != 20260927 or source_receipt.get("cells") != 115500 or
+            source_receipt.get("genes") != 6000 or source_receipt.get("modeled_genes") != 5975):
+        raise ValueError("embedded source metadata/readout differs from verified legacy run")
+    return {"arm": "scsemi", "npz": str(path), "npz_sha256": receipt["output_sha256"],
+            "receipt": str(receipt_path), "receipt_sha256": sha(receipt_path),
+            "source_binding": str(adoption_path), "source_binding_sha256": sha(adoption_path),
+            "condition_npz": str(strict_condition), "condition_sha256": receipt["condition_sha256"],
+            "checkpoint_sha256": None, "support_sha256": s["sha256"],
+            "source_kind": "verified_legacy_scsemi_adoption", "validation_sha256": sha(validation_path)}
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--support-manifest", required=True, type=Path)
+    p.add_argument("--action", required=True, choices=("prepare", "verify", "adopt", "export", "all"))
+    a = p.parse_args(argv)
+    if a.action in {"prepare", "all"}:
+        print(json.dumps({"prepared_strict_work": str(prepare(a.support_manifest))}), flush=True)
+    if a.action in {"verify", "all"}:
+        proof = verify(a.support_manifest)
+        print(json.dumps({"status": proof["status"], "unit": proof["unit"],
+                          "n_model_receipts": len(proof["model_sha256"]),
+                          "n_target_shards": len(proof["target_shard_sha256"]),
+                          "n_equal_prepared_assets": len(proof["prepared_assets_equal"])}), flush=True)
+    if a.action == "adopt":
+        proof = adopt(a.support_manifest)
+        print(json.dumps({"status": proof["status"], "unit": proof["unit"],
+                          "adopted_evidence_dir": proof["adopted_evidence_dir"],
+                          "linked_files": proof["linked_files"]}), flush=True)
+    if a.action == "export":
+        print(json.dumps(export_adopted(a.support_manifest)), flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 4 and sys.argv[1] == "--internal-compare":
+        _same_rep_cells(Path(sys.argv[2]), Path(sys.argv[3]))
+        raise SystemExit(0)
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/prepare_controls.py

@@ -0,0 +1,119 @@
+"""External AIFI calibration using target bulk and assay metadata, never target sc expression."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+M8 = ROOT.parents[1]
+LEGACY = M8 / "plans/paired_finetune_intradataset_20260927"
+REFERENCE = M8 / "plans/utility_studies_final6k_20260925/refcal/reference/aifi_donor_pseudobulk_20097.npz"
+COHORTS = ("immicro", "ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+
+
+def cpm(counts: np.ndarray) -> np.ndarray:
+    x = np.asarray(counts, dtype=np.float64)
+    if x.ndim != 2 or not np.isfinite(x).all() or (x < 0).any() or (x.sum(axis=1) <= 0).any():
+        raise ValueError("counts must be finite non-negative rows with positive totals")
+    return x / x.sum(axis=1, keepdims=True) * 1e6
+
+
+def external_multiplier(bulk: np.ndarray, bulk_valid: np.ndarray,
+                        reference_counts: np.ndarray, reference_present: np.ndarray) -> np.ndarray:
+    bulk = np.asarray(bulk, dtype=np.float64)
+    valid = np.asarray(bulk_valid, dtype=bool)
+    present = np.asarray(reference_present, dtype=bool)
+    if bulk.shape != valid.shape or present.shape != (bulk.shape[1],):
+        raise ValueError("assay mask or gene axis mismatch")
+    b = cpm(np.where(valid, bulk, 0)).mean(axis=0)
+    ref = cpm(reference_counts).mean(axis=0)
+    if ref.shape != b.shape:
+        raise ValueError("external reference gene axis mismatch")
+    keep = valid.all(axis=0) & present & (b >= 1.) & (ref >= 1.)
+    alpha = np.ones_like(b)
+    alpha[keep] = ref[keep] / b[keep]
+    return alpha
+
+
+def prepare(cohort: str) -> dict:
+    import pandas as pd
+    from runtime import atomic_json, sha256
+
+    sys.path.insert(0, str(LEGACY / "tools"))
+    import prepare_dataset as PD
+
+    data = LEGACY / "data" / cohort
+    out = ROOT / "data/external_refcal" / cohort
+    sources = [data / "features.npz", data / "folds.csv", REFERENCE, ROOT / "protocol/PROTOCOL.json"]
+    input_hashes = {str(p): sha256(p) for p in sources}
+    receipt = out / "BUILD.json"
+    if receipt.exists():
+        old = json.loads(receipt.read_text())
+        if old["input_hashes"] != input_hashes:
+            raise ValueError("external-calibration inputs changed; create a new version")
+        if all(Path(p).is_file() and sha256(Path(p)) == h for p, h in old["outputs"].items()):
+            return old
+        raise ValueError("external-calibration output changed or missing")
+    if out.exists() and any(out.iterdir()):
+        raise ValueError(f"unreceipted conditions exist at {out}; preserve and inspect")
+    out.mkdir(parents=True, exist_ok=True)
+    folds = pd.read_csv(data / "folds.csv")
+    with np.load(data / "features.npz", allow_pickle=False) as z:
+        # Do not call PD.load: that convenience function also materialises target pseudo_raw_sum.
+        ids = (z["sample_ids"] if "sample_ids" in z.files else z["donor_ids"]).astype(str)
+        if not np.array_equal(ids, folds.sample_id.astype(str).to_numpy()):
+            raise ValueError("features and folds disagree")
+        d = {"gene_ids": z["gene_ids"].astype(str), "sample_ids": ids,
+             "donor_ids": folds.donor_id.astype(str).to_numpy(), "groups": folds.group.astype(str).to_numpy(),
+             "sc_valid": z["sc_valid"].astype(bool), "n_cells": np.full(len(ids), -1, np.int64)}
+        valid = z["bulk_valid"].astype(bool)
+        bulk = np.where(valid, z["bulk_raw"], 0).astype(np.float64)
+    rows = np.flatnonzero(folds.fold.to_numpy() >= 0)
+    with np.load(REFERENCE, allow_pickle=False) as z:
+        if not np.array_equal(z["gene_ids"].astype(str), d["gene_ids"]):
+            raise ValueError("AIFI and cohort gene axes differ")
+        alpha = external_multiplier(bulk[rows], valid[rows], z["sums_full"], z["present"])
+        n_reference_donors = len(z["donor_ids"])
+    adjusted = cpm(bulk) * alpha[None, :]
+    counts = PD.RB.to_condition_counts(adjusted, valid)
+    raw = PD.RB.to_condition_counts(bulk, valid)
+    outputs = {}
+    for arm, arr in (("refcal", counts), ("raw", raw)):
+        p = out / f"conditions_{arm}.npz"
+        outputs[str(p)] = PD.write_npz(p, d, rows, arr, valid, 1500, f"strict_{arm}")
+    np.save(out / "alpha.npy", alpha)
+    outputs[str(out / "alpha.npy")] = sha256(out / "alpha.npy")
+    rec = {"schema": "pbisc.strict.external-reference.v1", "cohort": cohort,
+           "input_hashes": input_hashes, "outputs": outputs,
+           "target_bulk_anchor_sample_ids": ids[rows].tolist(), "target_sc_expression_accessed": False,
+           "output_assay_mask_source": "pre-existing structural assay metadata; no expression/depth fitting",
+           "reference": "external AIFI donor-mean CPM", "reference_donors": n_reference_donors,
+           "paired_target_samples_used": 0, "transductive_target_bulk": True,
+           "K_cond": 1000, "rho": 3869.603120208939, "N_gen": 1500,
+           "alpha_genes": int((alpha != 1.).sum())}
+    atomic_json(receipt, rec)
+    return rec
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--dataset", choices=COHORTS)
+    p.add_argument("--all", action="store_true")
+    a = p.parse_args()
+    if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+        raise SystemExit("CPU builder requires CUDA_VISIBLE_DEVICES=''")
+    if not a.dataset and not a.all:
+        p.error("choose --dataset or --all")
+    for cohort in COHORTS if a.all else (a.dataset,):
+        rec = prepare(cohort)
+        print(json.dumps({"cohort": cohort, "samples": len(rec["target_bulk_anchor_sample_ids"]),
+                          "alpha_genes": rec["alpha_genes"]}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/prepare_strict_pairs.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Materialize immutable exact-support manifests; optionally prepare CPU condition arrays.
+
+Usage: python prepare_strict_pairs.py --all [--conditions]
+       python prepare_strict_pairs.py --dataset immicro [--conditions]
+"""
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("CPU preparation requires CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+HERE = Path(__file__).resolve().parents[1]
+M8 = HERE.parents[1]
+OLD = M8 / "plans/paired_finetune_intradataset_20260927"
+sys.path.insert(0, str(HERE / "tools"))
+import support_manifest as SM  # noqa: E402
+
+DISEASE = ("ye2026_sepsis", "imperial_eskd", "giroux2022", "ji2025_chili")
+STRATA = {"ye2026_sepsis": "sepsis", "imperial_eskd": "positive", "giroux2022": "severe",
+          "ji2025_chili": "TOL|FU1"}
+
+
+def _load_pd():
+    path = OLD / "tools/prepare_dataset.py"
+    spec = importlib.util.spec_from_file_location("paired_prepare_dataset", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _unit_paths(cohort: str, m: dict) -> tuple[Path, Path]:
+    suffix = (Path("healthy") / m["unit"].split("_n")[0] / ("n" + str(m["n_pairs"]))
+              if cohort == "immicro" else Path("disease") / m["unit"].split("_n")[0])
+    return HERE / "protocol/splits" / cohort / suffix / "support.json", HERE / "data" / cohort / suffix
+
+
+def _prepare_conditions(cohort: str, m: dict, out: Path, folds: pd.DataFrame) -> None:
+    if out.exists() and any(out.iterdir()):
+        raise FileExistsError(f"condition output already exists: {out}")
+    PD = _load_pd()
+    d = PD.load(OLD / "data" / cohort)
+    if d["sample_ids"].astype(str).tolist() != folds.sample_id.astype(str).tolist():
+        raise ValueError("features and folds order mismatch")
+    pos = {s: i for i, s in enumerate(d["sample_ids"].astype(str))}
+    train = np.asarray([pos[s] for s in m["train_sample_ids"]], dtype=np.int64)
+    test = np.asarray([pos[s] for s in m["test_sample_ids"]], dtype=np.int64)
+    valid = d["bulk_valid"][train].all(axis=0) & d["sc_valid"][train].all(axis=0)
+    alpha = PD.RB.gene_multiplier(d["bulk"][train], d["pseudo"][train], valid)
+    raw = PD.RB.to_condition_counts(d["bulk"], d["bulk_valid"])
+    cal = PD.RB.to_condition_counts(PD.RB.cpm(d["bulk"]) * alpha[None, :], d["bulk_valid"])
+    out.mkdir(parents=True, exist_ok=False)
+    np.save(out / "alpha.npy", alpha)
+    hashes = {}
+    for arm, arr in (("raw", raw), ("cal", cal)):
+        hashes[f"test_{arm}.npz"] = PD.write_npz(out / f"test_{arm}.npz", d, test, arr,
+                                                d["bulk_valid"], 1500, arm)
+    (out / "test_samples.txt").write_text("\n".join(m["test_sample_ids"]) + "\n")
+    (out / "train_samples.txt").write_text("\n".join(m["train_sample_ids"]) + "\n")
+    (out / "CONDITIONS.json").write_text(json.dumps({"support_sha256": m["sha256"],
+                                                       "support_path": str(_unit_paths(cohort, m)[0]),
+                                                       "fit_sample_ids": m["train_sample_ids"],
+                                                       "alpha_genes_estimated": int((alpha != 1.0).sum()),
+                                                       "files_sha256": hashes}, indent=2) + "\n")
+
+
+def prepare(cohort: str, *, conditions: bool = False, unit: str | None = None) -> list[Path]:
+    if cohort not in ("immicro", *DISEASE):
+        raise ValueError(f"unknown cohort {cohort}")
+    ds = OLD / "data" / cohort
+    folds = pd.read_csv(ds / "folds.csv", dtype={"sample_id": str, "donor_id": str})
+    manifests = []
+    if cohort == "immicro":
+        units = (SM.build_healthy(folds, fold, n, seed=20261012 + fold)
+                 for fold in range(5) for n in (5, 10, 20, 40))
+    else:
+        pairs = pd.read_csv(ds / "pairs.csv", dtype={"sample_id": str, "donor_id": str})
+        units = (SM.build_disease(folds, pairs,
+                                 (ds / f"fewshot_n5/draw{draw}/train_donors.txt").read_text().splitlines(),
+                                 cohort, draw, strata_regex=STRATA[cohort]) for draw in range(5))
+    for m in units:
+        if unit is not None and m["unit"] != unit:
+            continue
+        if cohort in DISEASE and m["n_pairs"] != 5:
+            raise ValueError("disease draw must contain five pairs")
+        path, out = _unit_paths(cohort, m)
+        if path.exists():
+            old = SM.load_manifest(path, folds)
+            if old != m:
+                raise FileExistsError(f"different support exists: {path}")
+        else:
+            SM.write_manifest(path, m)
+        if conditions:
+            _prepare_conditions(cohort, m, out, folds)
+        manifests.append(path)
+    return manifests
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    group = ap.add_mutually_exclusive_group(required=True)
+    group.add_argument("--all", action="store_true")
+    group.add_argument("--dataset", choices=("immicro", *DISEASE))
+    ap.add_argument("--conditions", action="store_true", help="write test_raw/test_cal arrays using only support pairs")
+    ap.add_argument("--unit", help="one unit, e.g. fold0_n5 or draw0_n5; requires --dataset")
+    a = ap.parse_args(argv)
+    if a.unit and a.all:
+        ap.error("--unit requires --dataset")
+    cohorts = ("immicro", *DISEASE) if a.all else (a.dataset,)
+    result = {cohort: len(prepare(cohort, conditions=a.conditions, unit=a.unit)) for cohort in cohorts}
+    if a.unit and result[a.dataset] != 1:
+        ap.error(f"unit {a.unit!r} not found")
+    print(json.dumps({"prepared_support_units": result, "conditions": a.conditions}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

paper-releases/pbisc-diffusion/updates/20261012T130738Z-strictpairs-implementation/diffusion/dataset/server_1/model8/plans/paper_figures_strictpairs_20261012/archive/20261012T130738Z-strictpairs-implementation/snapshot/tools/rare_cache_builder.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""Build strict Figure 5 marker caches from generated NPZs and score_ft labels.
+
+The 6k generated array is streamed from ZIP to temporary disk and read via mmap.
+Poisson draws cover every NPZ row in original order, including unscored rows.
+No CUDA, model inference, or training occurs here.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("cache builder requires CUDA_VISIBLE_DEVICES=''")
+
+import numpy as np
+import pandas as pd
+
+from build_figure5 import FT, HERE, _observed_legacy
+
+M8 = HERE.parents[1]
+STATES = M8 / "plans/rare_states_screen_20261004/tools/states.json"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/"
+             "strict_qc_v1_20260913/reference/canonical_genes.tsv")
+POISSON_SEED = 20260916
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for block in iter(lambda: f.read(4 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def support_digest(data: dict) -> str:
+    body = {k: v for k, v in data.items() if k != "sha256"}
+    return hashlib.sha256(json.dumps(body, sort_keys=True, separators=(",", ":"),
+                                     allow_nan=False).encode()).hexdigest()
+
+
+def read_support(path: Path) -> dict:
+    x = json.loads(path.read_text())
+    if x.get("schema") != "pbisc.paper.strict-support.v1" or x.get("sha256") != support_digest(x):
+        raise ValueError("strict support schema/hash mismatch")
+    if len(x["train_sample_ids"]) != 5 or len(set(x["train_donor_ids"])) != 5:
+        raise ValueError("support is not five unique donor pairs")
+    if set(x["train_donor_ids"]) & set(x["test_donor_ids"]):
+        raise ValueError("support train/test donor overlap")
+    return x
+
+
+def _panel(cohort: str, states: list[dict]) -> tuple[np.ndarray, np.ndarray, list[str], np.ndarray]:
+    with np.load(FT / "data" / cohort / "cells_panel6k.npz", allow_pickle=False) as z:
+        panel = z["panel_gene_ids"].astype(str)
+        measured = z["panel_measured"].any(axis=0)
+    canon = pd.read_csv(CANON, sep="\t", dtype=str)
+    sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+    pos = {g: i for i, g in enumerate(panel)}
+    genes = list(dict.fromkeys(g for st in states for g in
+                  (st.get("genes", []) + [v for group in st.get("require_any", []) for v in group]
+                   + st.get("exclude", []))))
+    symbols = [g for g in genes if sym2id.get(g) in pos and measured[pos[sym2id[g]]]]
+    cols = np.array([pos[sym2id[g]] for g in symbols], dtype=int)
+    return panel, measured, symbols, cols
+
+
+def _score_rows(score: Path, arm: str, support: dict) -> tuple[pd.DataFrame, pd.DataFrame]:
+    gc = pd.read_parquet(score / "arms" / arm / "generated_cells.parquet")
+    lab = pd.read_parquet(score / "arms" / arm / "labels/labels.parquet")
+    if len(gc) != len(lab) or not np.array_equal(
+        lab.sample_id.astype(str).str.removesuffix("|generated"), gc.donor.astype(str)
+    ):
+        raise ValueError(f"{arm}: scored cells and labels are not row aligned")
+    if set(gc.donor.astype(str)) != set(support["test_sample_ids"]):
+        raise ValueError(f"{arm}: score rows differ from strict test samples")
+    if gc.npz_row.duplicated().any() or gc.npz_row.isna().any():
+        raise ValueError(f"{arm}: duplicate or missing NPZ row")
+    return gc, lab
+
+
+def validate_score_arm(score: Path, arm: str, npz_path: Path, npz_sha: str,
+                       support: dict) -> tuple[Path, str, Path, str]:
+    binding_path = score.parent / "scoring_support.json"
+    if not binding_path.is_file():
+        raise ValueError(f"{arm}: scoring support binding missing")
+    binding = json.loads(binding_path.read_text())
+    expected_binding = {
+        "schema": "pbisc.paper.strict-score-binding.v1",
+        "support_sha256": support["sha256"],
+        "cohort": support["cohort"],
+        "unit": support["unit"],
+        "test_sample_ids": support["test_sample_ids"],
+        "test_donor_ids": support["test_donor_ids"],
+    }
+    if any(binding.get(k) != v for k, v in expected_binding.items()):
+        raise ValueError(f"{arm}: scoring support binding mismatch")
+    summary_path = score / "summary.json"
+    summary = json.loads(summary_path.read_text())
+    if (summary.get("schema") != "paired_ft_scores.v1" or
+        summary.get("dataset") != support["cohort"] or
+        set(summary.get("donors", [])) != set(support["test_sample_ids"]) or
+        arm not in summary.get("arms", [])):
+        raise ValueError(f"{arm}: score summary not bound to strict cohort/test support")
+    scored = summary.get("per_arm", {}).get(arm, {})
+    if (scored.get("npz_sha256") != npz_sha or
+        Path(scored.get("npz", "")).resolve() != npz_path.resolve() or
+        scored.get("receipt_verified") is not True):
+        raise ValueError(f"{arm}: generated NPZ differs from scorer arm provenance")
+    if (scored.get("poisson", {}).get("seed") != POISSON_SEED or
+        scored.get("poisson", {}).get("rule") != "whole NPZ, rows in NPZ order"):
+        raise ValueError(f"{arm}: scorer Poisson provenance differs")
+    return summary_path, sha256(summary_path), binding_path, sha256(binding_path)
+
+
+def _stream_poisson(
+    rates: np.ndarray, selected: np.ndarray, measured: np.ndarray,
+    marker_cols: np.ndarray, score_cols: np.ndarray, *, chunk_rows: int = 512
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Small-memory exact whole-NPZ draw, then selected scored rows in their parquet order."""
+    n, genes = rates.shape
+    if selected.min(initial=0) < 0 or selected.max(initial=-1) >= n or len(set(selected)) != len(selected):
+        raise ValueError("scored NPZ row indices are invalid")
+    order = np.argsort(selected)
+    sorted_sel = selected[order]
+    markers = np.empty((len(selected), len(marker_cols)), dtype=np.int32)
+    libs = np.empty(len(selected), dtype=np.float32)
+    umis = np.empty(len(selected), dtype=np.float32)
+    rng = np.random.default_rng(POISSON_SEED)
+    for start in range(0, n, chunk_rows):
+        stop = min(start + chunk_rows, n)
+        block = np.asarray(rates[start:stop], dtype=np.float64)
+        if not np.isfinite(block).all() or (block < 0).any():
+            raise ValueError(f"invalid Poisson rates in rows {start}:{stop}")
+        drawn = rng.poisson(block)
+        lo, hi = np.searchsorted(sorted_sel, [start, stop])
+        if hi > lo:
+            dst = order[lo:hi]
+            chosen = drawn[sorted_sel[lo:hi] - start]
+            markers[dst] = chosen[:, marker_cols]
+            libs[dst] = chosen[:, measured].sum(axis=1)
+            umis[dst] = chosen[:, score_cols].sum(axis=1)
+    return markers, libs, umis
+
+
+def build_arm(npz_path: Path, score: Path, arm: str, support: dict, output: Path,
+              panel: np.ndarray, measured: np.ndarray, symbols: list[str],
+              marker_cols: np.ndarray, score_cols: np.ndarray) -> dict:
+    receipt_path = npz_path.with_suffix(".log")
+    if not receipt_path.is_file():
+        raise ValueError(f"{arm}: generation receipt absent")
+    receipt = json.loads(receipt_path.read_text())
+    actual_sha = sha256(npz_path)
+    if receipt.get("output_sha256") != actual_sha:
+        raise ValueError(f"{arm}: generated NPZ differs from receipt")
+    summary_path, summary_sha, binding_path, binding_sha = validate_score_arm(
+        score, arm, npz_path, actual_sha, support)
+    gc, lab = _score_rows(score, arm, support)
+    with zipfile.ZipFile(npz_path) as z:
+        with z.open("gene_ids.npy") as f:
+            ids = np.load(f, allow_pickle=False).astype(str)
+        with z.open("sample_ids.npy") as f:
+            sample_ids = np.load(f, allow_pickle=False).astype(str)
+        with z.open("bulk_index.npy") as f:
+            bulk_index = np.load(f, allow_pickle=False).astype(int)
+        if not np.array_equal(ids, panel):
+            raise ValueError(f"{arm}: generated gene panel differs")
+        selected = gc.npz_row.to_numpy(dtype=np.int64)
+        if selected.max(initial=-1) >= len(bulk_index) or selected.min(initial=0) < 0:
+            raise ValueError(f"{arm}: scored row outside generated NPZ")
+        if not np.array_equal(sample_ids[bulk_index[selected]], gc.donor.astype(str)):
+            raise ValueError(f"{arm}: scored sample IDs differ from generated NPZ")
+        output.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory(prefix="rare-npz-", dir=output.parent) as temp:
+            temp_npy = Path(temp) / "generated_counts.npy"
+            with z.open("generated_counts.npy") as source, temp_npy.open("wb") as dest:
+                shutil.copyfileobj(source, dest, length=4 << 20)
+            rates = np.load(temp_npy, mmap_mode="r", allow_pickle=False)
+            markers, libs, umis = _stream_poisson(rates, selected, measured, marker_cols, score_cols)
+            del rates
+    if not np.array_equal(umis, gc.umi_scoring_genes.to_numpy()):
+        raise ValueError(f"{arm}: benchmark UMI readout mismatch")
+    rec = {"schema": "pbisc.figure5.marker-cache.v1", "cohort": support["cohort"],
+           "unit": support["unit"], "arm": arm, "support_sha256": support["sha256"],
+           "generated_npz": str(npz_path.resolve()), "generated_npz_sha256": actual_sha,
+           "score_summary": str(summary_path.resolve()), "score_summary_sha256": summary_sha,
+           "scoring_support": str(binding_path.resolve()), "scoring_support_sha256": binding_sha,
+           "score_generated_cells": str((score / "arms" / arm / "generated_cells.parquet").resolve()),
+           "score_generated_cells_sha256": sha256(score / "arms" / arm / "generated_cells.parquet"),
+           "score_labels_sha256": sha256(score / "arms" / arm / "labels/labels.parquet"),
+           "poisson_seed": POISSON_SEED, "benchmark_umi_reproduced": True, "cells": len(gc)}
+    np.savez_compressed(output, markers=markers, marker_symbols=np.asarray(symbols),
+                        lib_measured=libs, sample_id=gc.donor.astype(str).to_numpy(),
+                        aifi_l1=lab.aifi_l1.astype(str).to_numpy(),
+                        aifi_l2=lab.aifi_l2.astype(str).to_numpy(), receipt=json.dumps(rec))
+    return rec
+
+
+def build(support_path: Path, score: Path, arms: dict[str, Path], output: Path,
+          *, cell_budget: int, depth_target: float) -> Path:
+    support = read_support(support_path)
+    summary = json.loads((score / "summary.json").read_text())
+    if summary.get("dataset") != support["cohort"] or set(summary.get("donors", [])) != set(support["test_sample_ids"]):
+        raise ValueError("score summary not bound to strict test samples")
+    if set(summary.get("arms", [])) != set(arms):
+        raise ValueError("score summary arm set differs")
+    states = json.loads(STATES.read_text())
+    panel, measured, symbols, cols = _panel(support["cohort"], states)
+    ref = np.load(FT / "scoring_cache" / support["cohort"] / "reference.npz", allow_pickle=False)
+    score_cols = ref["score_idx"].astype(int)
+    output.mkdir(parents=True, exist_ok=True)
+    observed = _observed_legacy(support["cohort"], states)
+    obs_path = output / "observed.npz"
+    np.savez_compressed(obs_path, **observed)
+    paths = {}
+    cache_sha = {}
+    for arm, source in arms.items():
+        path = output / f"{arm}.npz"
+        build_arm(source, score, arm, support, path, panel, measured, symbols, cols, score_cols)
+        paths[arm] = str(path.resolve())
+        cache_sha[arm] = sha256(path)
+    metadata = FT / "data" / support["cohort"] / "pairs.csv"
+    unit = {"cohort": support["cohort"], "unit": support["unit"].removesuffix("_n5"),
+            "design": "strict5pair", "train_sample_ids": support["train_sample_ids"],
+            "train_donor_ids": support["train_donor_ids"], "test_sample_ids": support["test_sample_ids"],
+            "sample_metadata": str(metadata.resolve()), "support_manifest": str(support_path.resolve()),
+            "observed_cache": str(obs_path.resolve()), "observed_cache_sha256": sha256(obs_path),
+            "generated_caches": paths, "generated_cache_sha256": cache_sha,
+            "cell_budget": cell_budget, "depth_target": depth_target}
+    manifest = output / "rare_manifest.json"
+    manifest.write_text(json.dumps({"schema": "pbisc.figure5.marker-caches.v1",
+                                    "units": [unit]}, indent=2) + "\n")
+    return manifest
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--support-manifest", type=Path, required=True)
+    ap.add_argument("--score-dir", type=Path, required=True, help="score_strict output's score/ directory")
+    ap.add_argument("--arm", action="append", required=True, help="NAME=generated.npz")
+    ap.add_argument("--output-dir", type=Path, required=True)
+    ap.add_argument("--cell-budget", type=int, required=True)
+    ap.add_argument("--depth-target", type=float, required=True)
+    a = ap.parse_args()
+    if a.cell_budget <= 0 or a.depth_target <= 0:
+        raise ValueError("positive common cell budget and depth target required")
+    arms = {}
+    for value in a.arm:
+        name, sep, raw = value.partition("=")
+        if sep != "=" or not name or name in arms or not raw:
+            raise ValueError(f"invalid arm {value!r}")
+        arms[name] = Path(raw)
+    print(build(a.support_manifest, a.score_dir, arms, a.output_dir,
+                cell_budget=a.cell_budget, depth_target=a.depth_target))
+
+
+if __name__ == "__main__":
+    main()