Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/fetch_s2.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Bring the Imperial K = 4,000 draws generated on spark-0110 (server_2) back to this host (2026-10-06).
+# Why: server_2's GPU became free (its root-owned vLLM stopped) while this host's GPU was working through sepsis, so
+# Imperial draws DRAWS (default "2 3 4") run there (tools/run_gpu.sh imperial_eskd, unit bulkonly-k4000-gpu-s2; same
+# code, data, base checkpoint, torch 2.14.0+cu130 and numpy 2.4.2 on both hosts, sha-checked 2026-10-06).  This
+# host's queue files of those draws are stubs (full queue: queues/<ds>_draw<j>.txt.full), so its runner skips them;
+# server_2's queue files of the other draws are stubs.
+# For each draw, once server_2's logs/gpu_imperial_eskd_draw<j>.log says "complete":
+#   rsync generated/imperial_eskd/draw<j>/ and runs/imperial_eskd/draw<j>/lora_k4000/ to the same paths here, without
+#   checkpoint_ft.pt (the LoRA weights stay on server_2, where model_8 checkpoints are kept; the CPU tools check the
+#   receipts' checkpoint sha against RUN.json);
+#   every NPZ's sha256 must equal its receipt and every queue step must have its output, else WARN (draw held back);
+#   then copy the draw's GPU log, which releases the draw to tools/run_cpu.sh.
+# Stops with WARN if server_2's runner is no longer active while a draw is incomplete.  usage: fetch_s2.sh [DRAWS...]
+set -uo pipefail
+P4=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bulkonly_lora5_k4000_20261006
+R=spark-0110
+ds=imperial_eskd
+DRAWS=("${@:-2 3 4}"); read -r -a DRAWS <<< "${DRAWS[*]}"
+LOG=$P4/logs/fetch_s2_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+rsh() { ssh -n -o BatchMode=yes "$R" "export XDG_RUNTIME_DIR=/run/user/\$(id -u); export DBUS_SESSION_BUS_ADDRESS=unix:path=\$XDG_RUNTIME_DIR/bus; $*"; }
+declare -A done_d=()
+log "fetcher start: $ds draws ${DRAWS[*]} from $R"
+while (( ${#done_d[@]} < ${#DRAWS[@]} )); do
+  for j in "${DRAWS[@]}"; do
+    [[ -n "${done_d[$j]:-}" ]] && continue
+    glog=$P4/logs/gpu_${ds}_draw${j}.log
+    if rsh "grep -q '=== $ds draw$j complete' '$glog'"; then
+      log "draw$j complete on $R; fetching"
+      mkdir -p "$P4/generated/$ds/draw$j" "$P4/runs/$ds/draw$j/lora_k4000"
+      rsync -a "$R:$P4/generated/$ds/draw$j/" "$P4/generated/$ds/draw$j/" >> "$LOG" 2>&1 \
+        && rsync -a --exclude checkpoint_ft.pt "$R:$P4/runs/$ds/draw$j/lora_k4000/" "$P4/runs/$ds/draw$j/lora_k4000/" >> "$LOG" 2>&1 \
+        || { log "WARN: rsync of draw$j failed; retry next round"; continue; }
+      if python3 - "$P4/queues/${ds}_draw${j}.txt.full" >> "$LOG" 2>&1 <<'EOF'
+import hashlib, json, os, sys
+def sha(p):
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+bad = 0
+for line in open(sys.argv[1]):
+    f = line.strip().split("|")
+    if f[0] == "train":
+        bad += not os.path.exists(os.path.join(f[1], "RUN.json"))
+    elif f[0] == "sample":
+        rec = json.load(open(f[4][:-4] + ".log"))
+        ok = sha(f[4]) == rec["output_sha256"]
+        print(("ok " if ok else "SHA MISMATCH ") + os.path.basename(f[4]), rec["output_sha256"][:12])
+        bad += not ok
+sys.exit(1 if bad else 0)
+EOF
+      then
+        rsync -a "$R:$glog" "$glog" >> "$LOG" 2>&1
+        done_d[$j]=1
+        log "draw$j fetched and verified (every NPZ sha = its receipt); released to run_cpu.sh"
+      else
+        log "WARN: draw$j failed verification after fetch (see log); held back"
+        done_d[$j]=failed
+      fi
+    elif ! rsh "systemctl --user is-active --quiet bulkonly-k4000-gpu-s2"; then
+      log "WARN: server_2 runner inactive and draw$j incomplete; fetcher stops"; exit 1
+    fi
+  done
+  (( ${#done_d[@]} < ${#DRAWS[@]} )) && sleep 120
+done
+log "all assigned draws handled: $(for j in "${!done_d[@]}"; do printf 'draw%s=%s ' "$j" "${done_d[$j]}"; done)"

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/gpu_draw.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# One few-pair draw's K = 4,000 GPU work (2026-10-06).  Runs INSIDE one ml-run step (ml.slice, shared GPU lock held
+# for the whole draw, so the scSemiProfiler queue gets the GPU between draws).  Steps: queues/<ds>_draw<j>.txt
+# (tools/make_queue.py), in order:
+#   train   paired_finetune_intradataset_20260927/tools/ft_sdd.py with the LoRA-5 protocol (base f01 6k 1x E16,
+#           --mode lora --lr 5e-4 --fold 0 --fixed-steps 3000, LoRA r16, seed 20260927, the draw's train_donors.txt)
+#           on the K = 4,000 training condition; skipped when RUN.json exists; checkpoint sha must equal RUN.json
+#   sample  scripts/sample_sdd_standalone.py with the benchmark's flags (EMA, DDIM 50, Bernoulli support read-out,
+#           threshold 0, batch 256, embedded conditioner); stdout = JSON receipt <out>.log, stderr <out>.err, peak
+#           memory <out>.time (GNU time -v); skipped when the NPZ exists and its receipt has an output_sha256
+# Before each step: MemAvailable >= 32 GiB floor + the step's peak estimate (0.45 GiB per 1,000 cells; 16 GiB for
+# training) and the thermal gate, waiting at most WAIT_MIN (120) minutes.  A failure ends the step with exit 1 (the
+# runner stops; no retry); a failed sampler's partial outputs are kept under generated/_failed/<stamp>/.
+# usage (tools/run_gpu.sh): ml-run /bin/bash gpu_draw.sh DATASET DRAW
+set -uo pipefail
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+P4=$M8/plans/bulkonly_lora5_k4000_20261006
+FT=$M8/plans/paired_finetune_intradataset_20260927
+BASE=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+THERMAL=$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh
+for cand in /home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python /home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python; do
+  [[ -x "$cand" ]] && { PY=$cand; break; }
+done
+export CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1
+ds=$1; j=$2
+Q=$P4/queues/${ds}_draw${j}.txt
+LOG=$P4/logs/gpu_${ds}_draw${j}.log
+log() { echo "$(date +%FT%T) $*" >> "$LOG"; }
+fail() { log "FAIL: $*"; exit 1; }
+gate() {   # gate NEED_GIB -> prints "MemAvailable ..; thermal verdict"
+  local need=$1 t0 a v
+  t0=$(date +%s)
+  while :; do
+    a=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
+    if (( a >= need )) && v=$(bash "$THERMAL"); then echo "MemAvailable ${a} GiB >= ${need}; $v"; return 0; fi
+    (( $(date +%s) - t0 > ${WAIT_MIN:-120} * 60 )) && { echo "MemAvailable ${a} GiB < ${need} or GPU hot"; return 1; }
+    sleep 30
+  done
+}
+[[ -s "$Q" ]] || fail "queue missing: $Q"
+[[ -n "${PY:-}" ]] || fail "no torch python on this host"
+log "=== $ds draw$j on $(hostname -s), py=$PY, unit=${INVOCATION_ID:-?}"
+CK=""
+while IFS='|' read -r kind a1 a2 a3 a4 a5 <&3; do   # queue on fd 3: no step can eat it
+  [[ -z "${kind// }" || $kind == \#* ]] && continue
+  if [[ $kind == train ]]; then
+    run=$a1; cond=$a2; donors=$a3
+    mkdir -p "$run"
+    if [[ -s $run/RUN.json && -s $run/checkpoint_ft.pt ]]; then
+      log "train $(basename "$run"): done already"
+    else
+      g=$(gate 48) || fail "train gate: $g"
+      log "--- train $run ($g)"
+      "$PY" -u "$FT/tools/ft_sdd.py" --checkpoint "$BASE" --checkpoint-sha "$BASE_SHA" --dataset-dir "$FT/data/$ds" \
+        --condition-npz "$cond" --fold 0 --mode lora --lr 5e-4 --out-dir "$run" --train-donors-file "$donors" \
+        --fixed-steps 3000 >> "$run/train.log" 2>&1 || fail "train failed (see $run/train.log)"
+    fi
+    want=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['checkpoint_sha256'])" "$run/RUN.json") \
+      || fail "RUN.json unreadable"
+    got=$(sha256sum "$run/checkpoint_ft.pt" | cut -d' ' -f1)
+    [[ "$got" == "$want" ]] || fail "checkpoint sha ${got:0:12} != RUN.json ${want:0:12}"
+    log "train ok: $(python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print(d['steps_run'],'steps',d['wall_seconds'],'s','rows',len(d['train_rows']),'sha',d['checkpoint_sha256'][:12])" "$run/RUN.json")"
+    CK=$run/checkpoint_ft.pt
+  elif [[ $kind == sample ]]; then
+    tag=$a1; cond=$a2; seed=$a3; out=$a4; cells=$a5
+    [[ -n "$CK" ]] || fail "$tag: no trained checkpoint before sampling"
+    rec=${out%.npz}.log; err=${out%.npz}.err; tim=${out%.npz}.time
+    if [[ -s $out && -s $rec ]] && python3 -c "import json,sys;assert json.load(open(sys.argv[1]))['output_sha256']" "$rec" 2>/dev/null; then
+      log "$tag: sampled already"; continue
+    fi
+    [[ -s $cond ]] || fail "$tag: condition missing $cond"
+    mkdir -p "$(dirname "$out")"
+    g=$(gate $(( 32 + (cells * 45 + 99999) / 100000 ))) || fail "$tag gate: $g"
+    log "--- $tag cells=$cells seed=$seed ($g)"
+    if /usr/bin/time -v -o "$tim" env PYTHONPATH="$M8/src" "$PY" -u "$M8/scripts/sample_sdd_standalone.py" \
+         --checkpoint "$CK" --condition-npz "$cond" --output "$out" --weights ema --batch-size 256 --steps 50 \
+         --seed "$seed" --device cuda --conditioner-source embedded --active-logit-threshold 0.0 \
+         --support-readout bernoulli > "$rec" 2> "$err"; then
+      log "$tag done: $(python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print('cells',d['cells'],'bulks',d['bulks'],'zero_frac %.4f' % d['generated_zero_fraction'],'sha',d['output_sha256'][:12])" "$rec") peak_rss $(awk -F': ' '/Maximum resident/ {printf "%.1f GiB", $2/1048576}' "$tim") wall $(awk -F': ' '/Elapsed/ {print $2}' "$tim")"
+    else
+      stamp=$(date +%Y%m%dT%H%M%S); keep=$P4/generated/_failed/$stamp; mkdir -p "$keep"
+      mv -f "$out" "$rec" "$err" "$tim" "$keep/" 2>/dev/null
+      fail "$tag sampler failed; partial outputs kept in $keep"
+    fi
+  else
+    fail "unknown queue line kind: $kind"
+  fi
+done 3< "$Q"
+log "=== $ds draw$j complete"

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/make_queue.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Write the GPU queue of each few-pair draw of one cohort (CPU only; 2026-10-06).  Read by tools/gpu_draw.sh.
+
+queues/<ds>_draw<j>.txt, in order:
+  train|RUN_DIR|TRAIN_CONDITION|TRAIN_DONORS_FILE
+      LoRA r16 on the draw's training donors (FT data/<ds>/fewshot_n5/draw<j>/train_donors.txt, the K = 1,000 draw's
+      donors) with the K = 4,000 training condition, fixed 3,000 steps: the LoRA-5 protocol with only K changed
+  sample|TAG|CONDITION_PART|SEED|OUTPUT_NPZ|CELLS
+      the draw's paired-test parts (1,500 cells per sample), then the bulk-only parts (4,000 cells per sample)
+Seeds.  Draw j uses base seed 20260927 + j * 1,000,003 for both sets; a part starting at row r0 adds r0 * 10,000,019
+(the PARTS.json seed), so every cell has the seed it would have in the unsplit file of its draw.  The K = 1,000
+version used 20260927 for every draw, so its five draws share per-cell noise (its completeness review); the offset
+makes the five K = 4,000 draws independent.  Draw 0 keeps 20260927.  No cell of one draw shares a noise or support
+seed with a cell of another draw: cells per row are < 7,919 and the draw offsets (<= 4,000,012) are not multiples of
+10,000,019 and differ from them by more than 11,918.  Within a draw, the paired-test and bulk-only files reuse the
+same seeds by row, as in the K = 1,000 version (different samples and conditions, never compared cell by cell).
+usage: CUDA_VISIBLE_DEVICES='' make_queue.py DATASET
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+if os.environ.get("CUDA_VISIBLE_DEVICES") != "":
+    raise SystemExit("run with CUDA_VISIBLE_DEVICES=''")
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+PLAN = Path(__file__).resolve().parents[1]
+BASE_SEED = 20260927
+DRAW_STRIDE = 1_000_003
+ROW_STRIDE = 10_000_019
+K = 4000
+
+
+def parts(manifest: Path, draw: int) -> list[dict]:
+    m = json.loads(manifest.read_text())
+    if m["base_seed"] != BASE_SEED or m["row_stride"] != ROW_STRIDE:
+        raise SystemExit(f"{manifest}: unexpected base seed / row stride")
+    out = []
+    for p in m["parts"]:
+        if p["seed"] != BASE_SEED + p["rows"][0] * ROW_STRIDE:
+            raise SystemExit(f"{manifest}: part {p['part']} seed")
+        out.append({**p, "path": manifest.parent / p["file"], "draw_seed": p["seed"] + draw * DRAW_STRIDE})
+    return out
+
+
+def main(argv=None) -> int:
+    ds = (argv or sys.argv[1:])[0]
+    data = PLAN / "data" / ds
+    draws = json.loads((FT / "data" / ds / "fewshot_n5" / "DRAWS.json").read_text())["draw"]
+    (PLAN / "queues").mkdir(exist_ok=True)
+    summary = {}
+    for j in sorted(draws, key=int):
+        jj = int(j)
+        if not 0 <= jj <= 4:
+            raise SystemExit("draw index out of the seed-offset range checked above")
+        gen = PLAN / "generated" / ds / f"draw{jj}"
+        lines = [f"# {ds} draw {jj}: LoRA r16 at K = {K} on the draw's 5 training donors, then paired-test parts "
+                 f"(1,500 cells per sample) and bulk-only parts (4,000 cells per sample); base seed "
+                 f"{BASE_SEED + jj * DRAW_STRIDE}",
+                 f"train|{PLAN}/runs/{ds}/draw{jj}/lora_k{K}|{data}/conditions_raw_fixed_K{K}.npz|"
+                 f"{FT}/data/{ds}/fewshot_n5/draw{jj}/train_donors.txt"]
+        n_cells = 0
+        for kind, man, stem in (("paired", data / "paired_test" / f"draw{jj}_test_raw_K{K}.PARTS.json", "paired_test"),
+                                ("bulkonly", data / f"bulkonly_raw_K{K}.PARTS.json", "bulkonly")):
+            for p in parts(man, jj):
+                lines.append(f"sample|{ds}_d{jj}_{kind}_p{p['part']}|{p['path']}|{p['draw_seed']}|"
+                             f"{gen}/{stem}_K{K}_part{p['part']}.npz|{p['cells']}")
+                n_cells += p["cells"]
+        q = PLAN / "queues" / f"{ds}_draw{jj}.txt"
+        q.write_text("\n".join(lines) + "\n")
+        summary[jj] = {"queue": str(q), "steps": len(lines) - 1, "cells": n_cells}
+    print(json.dumps(summary, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261006T033847Z-bulkonly-lora5-k4000/diffusion/dataset/server_1/model8/plans/bulkonly_lora5_k4000_20261006/tools/merge_paired.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Merge one draw's K = 4,000 paired-test parts into the one NPZ the benchmark scorer reads (CPU only; 2026-10-06).
+
+Why: score_ft.py takes one NPZ per arm and reads it out with one Poisson draw over the whole file.  The paired-test
+set of a draw was generated in row parts (tools/split_conditions.py, seed-equivalent: each cell has the seed of the
+unsplit draw file), so the parts concatenated in row order are that draw's unsplit generation.
+Checks: each part's NPZ sha equals its receipt, its condition sha the part file of
+data/<ds>/paired_test/draw<j>_test_raw_K4000.PARTS.json, its seed the queue seed (PARTS seed + draw x 1,000,003), and
+every part has the checkpoint of runs/<ds>/draw<j>/lora_k4000/RUN.json and the same gene axis.
+Output generated/<ds>/draw<j>/paired_test_K4000.npz (compressed) with the keys the scorer and extract_paired.py read:
+  generated_counts (cells x 6k float32, parts concatenated), bulk_index (shifted by each part's first row),
+  sample_ids, recipe_k, cells_per_bulk, bulk_measurement_fraction, output_availability_mask (per bulk, concatenated),
+  gene_ids, gene_symbols, gene_positions (equal in every part), metadata_json (the first part's, with
+  input_condition_path / sha256 = the unsplit draw condition, seed = the draw's base seed, merged_from = the parts).
+The other per-cell arrays (generated_log1p, active_logits, active_mask, support_mask) stay in the part files.
+Receipt <merged>.log (JSON, the sampler receipt's keys that the scorer reads): output_sha256, condition_npz,
+condition_sha256, checkpoint, checkpoint_sha256, seed, cells, bulks, parts.
+usage: CUDA_VISIBLE_DEVICES='' merge_paired.py DATASET DRAW
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+import time
+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
+
+PLAN = Path(__file__).resolve().parents[1]
+DRAW_STRIDE = 1_000_003          # tools/make_queue.py
+K = 4000
+
+
+def sha(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def main(argv=None) -> int:
+    t0 = time.monotonic()
+    ds, j = (argv or sys.argv[1:])[0], int((argv or sys.argv[1:])[1])
+    cdir = PLAN / "data" / ds / "paired_test"
+    man = json.loads((cdir / f"draw{j}_test_raw_K{K}.PARTS.json").read_text())
+    unsplit = Path(man["source"])
+    if sha(unsplit) != man["source_sha256"]:
+        raise SystemExit(f"{unsplit}: sha differs from PARTS.json")
+    run = json.loads((PLAN / "runs" / ds / f"draw{j}" / f"lora_k{K}" / "RUN.json").read_text())
+    gdir = PLAN / "generated" / ds / f"draw{j}"
+    out = gdir / f"paired_test_K{K}.npz"
+    per_cell, per_bulk, fixed, parts, meta0, rec0 = {"generated_counts": [], "bulk_index": []}, {}, {}, [], None, None
+    for p in man["parts"]:
+        npz = gdir / f"paired_test_K{K}_part{p['part']}.npz"
+        rec = json.loads(npz.with_suffix(".log").read_text())
+        got = sha(npz)
+        if got != rec["output_sha256"]:
+            raise SystemExit(f"{npz.name}: sha {got[:12]} != receipt {rec['output_sha256'][:12]}")
+        if rec.get("condition_sha256") != p["sha256"] or sha(cdir / p["file"]) != p["sha256"]:
+            raise SystemExit(f"{npz.name}: condition sha differs from {p['file']}")
+        if int(rec["seed"]) != int(p["seed"]) + j * DRAW_STRIDE:
+            raise SystemExit(f"{npz.name}: seed {rec['seed']} is not the queue seed")
+        if rec.get("checkpoint_sha256") != run["checkpoint_sha256"]:
+            raise SystemExit(f"{npz.name}: checkpoint differs from RUN.json")
+        d = np.load(npz, allow_pickle=False)
+        n_rows = int(d["sample_ids"].shape[0])
+        if n_rows != p["n_samples"]:
+            raise SystemExit(f"{npz.name}: {n_rows} bulks != PARTS.json {p['n_samples']}")
+        per_cell["generated_counts"].append(np.asarray(d["generated_counts"], dtype=np.float32))
+        per_cell["bulk_index"].append(d["bulk_index"].astype(np.int64) + int(p["rows"][0]))
+        for key in ("sample_ids", "recipe_k", "cells_per_bulk", "bulk_measurement_fraction", "output_availability_mask"):
+            per_bulk.setdefault(key, []).append(d[key])
+        for key in ("gene_ids", "gene_symbols", "gene_positions"):
+            if key in fixed and not np.array_equal(fixed[key], d[key]):
+                raise SystemExit(f"{npz.name}: {key} differs between parts")
+            fixed[key] = d[key]
+        if meta0 is None:
+            meta0, rec0 = json.loads(str(d["metadata_json"])), rec
+        parts.append({"part": p["part"], "rows": p["rows"], "npz": str(npz), "sha256": got, "seed": int(rec["seed"]),
+                      "condition": str(cdir / p["file"]), "condition_sha256": p["sha256"], "cells": int(rec["cells"])})
+    arrays = {k: np.concatenate(v) for k, v in per_cell.items()} | {k: np.concatenate(v) for k, v in per_bulk.items()} | fixed
+    z = np.load(unsplit, allow_pickle=True)
+    if not np.array_equal(arrays["sample_ids"].astype(str), z["sample_ids"].astype(str)):
+        raise SystemExit("merged sample order differs from the unsplit condition")
+    if not (np.bincount(arrays["bulk_index"], minlength=len(z["sample_ids"])) == z["cells_per_bulk"]).all():
+        raise SystemExit("cells per sample differ from the unsplit condition")
+    if not np.all(np.diff(arrays["bulk_index"]) >= 0):
+        raise SystemExit("bulk_index is not in row order")
+    base_seed = int(man["base_seed"]) + j * DRAW_STRIDE
+    meta = dict(meta0)
+    meta.update({"input_condition_path": str(unsplit), "input_condition_sha256": man["source_sha256"],
+                 "seed": base_seed, "merged_from": parts,
+                 "merge_note": "row parts of one draw concatenated in row order (seed-equivalent to the unsplit file)"})
+    arrays["metadata_json"] = np.array(json.dumps(meta))
+    np.savez_compressed(out, **arrays)
+    out_sha = sha(out)
+    receipt = {"output": str(out), "output_sha256": out_sha, "condition_npz": str(unsplit),
+               "condition_sha256": man["source_sha256"], "checkpoint": rec0.get("checkpoint"),
+               "checkpoint_sha256": run["checkpoint_sha256"], "seed": base_seed, "cells": int(arrays["bulk_index"].size),
+               "bulks": int(arrays["sample_ids"].size), "genes": int(arrays["generated_counts"].shape[1]),
+               "weights": rec0.get("weights"), "steps": rec0.get("steps"), "torch_version": rec0.get("torch_version"),
+               "parts": parts, "merged_utc": datetime.now(timezone.utc).isoformat(),
+               "tool": str(Path(__file__).resolve()), "tool_sha256": sha(Path(__file__)),
+               "seconds": round(time.monotonic() - t0, 1)}
+    out.with_suffix(".log").write_text(json.dumps(receipt, indent=1) + "\n")
+    print(json.dumps({k: receipt[k] for k in ("output_sha256", "cells", "bulks", "seed", "seconds")}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())