Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Move a finished scSemiProfiler split's bulky, no-longer-read files to spark-0110 at the SAME ABSOLUTE PATH (2026-10-02):
+#   scsemi_project/models/* (pretrain checkpoints and per-target models; their .receipt.json files stay here) and
+#   inputs/rep_sc.h5ad (its sha256 stays in inputs/inputs_manifest.json).
+# A local file is deleted only after spark-0110's sha256 of the copy equals the local sha256; the files and shas are
+# appended to <work>/offloaded_to_server2.tsv.  Refuses a split whose generated NPZ is not exported and validated, and
+# refuses relative paths (a relative path once put files under the remote $HOME; see tools/move_generated.sh).
+# Do not offload a CV run before every budget split that reuses it (--reuse-from) has finished: its 'link' phase reads
+# the CV checkpoints.  To resume a split later, rsync the files back first (same paths).
+# usage: offload_work.sh VALIDATION_JSON WORK [VALIDATION_JSON WORK ...]      (absolute paths)
+set -uo pipefail
+REMOTE=spark-0110
+n_ok=0; n_fail=0
+while (( $# >= 2 )); do
+  val=$1; work=$2; shift 2
+  [[ $work == /* && $val == /* ]] || { echo "FAIL relative path: $work $val"; n_fail=$((n_fail+1)); continue; }
+  W=$(realpath -e "$work") || { echo "FAIL no such dir $work"; n_fail=$((n_fail+1)); continue; }
+  python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "$val" 2>/dev/null \
+    || { echo "SKIP $W: $val missing or not passed"; n_fail=$((n_fail+1)); continue; }
+  M=$W/scsemi_project/models
+  names=$(mktemp); shas=$(mktemp)
+  find "$M" -maxdepth 1 -type f ! -name '*.receipt.json' -printf '%f\n' 2>/dev/null | sort > "$names"
+  have_in=0; [[ -f $W/inputs/rep_sc.h5ad ]] && have_in=1
+  if [[ ! -s $names ]] && (( ! have_in )); then echo "nothing to move in $W"; rm -f "$names" "$shas"; continue; fi
+  { sed "s|^|$M/|" "$names"; (( have_in )) && echo "$W/inputs/rep_sc.h5ad"; } | xargs -r -d '\n' sha256sum > "$shas"
+  ok=1
+  ssh -n "$REMOTE" "mkdir -p '$M' '$W/inputs'" || ok=0
+  if (( ok )) && [[ -s $names ]]; then
+    ionice -c3 rsync -a --bwlimit=200000 --files-from="$names" "$M/" "$REMOTE:$M/" || ok=0
+  fi
+  if (( ok && have_in )); then
+    ionice -c3 rsync -a --bwlimit=200000 "$W/inputs/rep_sc.h5ad" "$REMOTE:$W/inputs/" || ok=0
+  fi
+  if (( ok )) && ssh "$REMOTE" "sha256sum -c --quiet -" < "$shas"; then
+    awk '{print $2}' "$shas" | xargs -r -d '\n' rm -f
+    awk -v t="$(date -Is)" -v r="$REMOTE" '{print t "\t" r "\t" $2 "\t" $1}' "$shas" >> "$W/offloaded_to_server2.tsv"
+    echo "moved $(wc -l < "$shas") files of $W to $REMOTE (same paths, sha-verified)"; n_ok=$((n_ok+1))
+  else
+    echo "FAIL transfer or remote sha256 mismatch for $W; local files kept"; n_fail=$((n_fail+1))
+  fi
+  rm -f "$names" "$shas"
+done
+echo "offloaded=$n_ok failed=$n_fail"
+(( n_fail == 0 ))

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

@@ -0,0 +1,290 @@
+#!/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) -> dict:
+    data = TASK / "data" / ds
+    usable = folds["fold"].to_numpy() >= 0
+    donors = folds["donor_id"].astype(str).to_numpy()
+    extra = {}
+    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")
+    a = ap.parse_args(argv)
+    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)
+    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)
+    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 == "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/20261002T002920Z-deck-extra-metrics-scsemi-prep/diffusion/dataset/server_1/model8/plans/paired_finetune_intradataset_20260927/scsemi/tools/reuse_gpu_check.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Minimal GPU confirmation that a reused pretraining equals a fresh one (coordinating agent only; one GPU call, ~3-6 min).
+# Run once after work/<ds>/cv/fold<k> has pretrained (its prepared.json and receipted checkpoints exist), before the
+# budget lines that reuse it.  Nothing under work/ or generated/ is written.
+#   1. CPU units: build the budget split (fold k, n) in validation/reuse_gpu_check_20261002/<ds>_fold<k>_n<n>/ and prepare
+#      it with --reuse-from the CV run (hvset copied; every representative's sample_sc / geneset_scores must be
+#      byte-identical to the CV run's, else prepare refuses);
+#   2. GPU (thermal gate + gpu_usable.sh, then ml-run, as run_queue_scsemi.sh): phase pretrain --max-reps 1 with
+#      --reuse-from, i.e. the first representative pretrained FROM SCRATCH with the CV run's seeds (no link);
+#   3. CPU unit: tools/compare_runs.py fresh vs CV checkpoints (torch.equal on every tensor) ->
+#      validation/reuse_gpu_check_20261002_<ds>_fold<k>_n<n>.json; the check dir's prepared cell graphs are then deleted.
+# usage: reuse_gpu_check.sh [DATASET (immicro)] [FOLD (0)] [N (5)]
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+S=$M8/plans/paired_finetune_intradataset_20260927/scsemi
+[[ "$(hostname -s)" == spark-fa6b ]] || { echo "server_1 only (frozen runtime_env)" >&2; exit 2; }
+PY=$M8/plans/immicro_scsemi_comparison_20260927/runtime_env/bin/python
+ds=${1:-immicro}; k=${2:-0}; n=${3:-5}
+A=$S/work/$ds/cv/fold$k
+W=$S/validation/reuse_gpu_check_20261002/${ds}_fold${k}_n$n
+OUT=$S/validation/reuse_gpu_check_20261002_${ds}_fold${k}_n$n.json
+[[ -s $A/prepared.json ]] || { echo "CV run $A is not prepared" >&2; exit 1; }
+ls "$A"/scsemi_project/models/fastreconst2_*.receipt.json >/dev/null 2>&1 || { echo "CV run $A has no pretrain-2 checkpoints yet" >&2; exit 1; }
+mkdir -p "$W"
+if [[ ! -s $W/inputs/inputs_manifest.json ]]; then
+  ALLOW_USER_SITE=1 bash "$S/tools/cpu_unit.sh" "rgc-in-${ds:0:3}$k" 4 12 "$PY" -u "$S/tools/prepare_draw_inputs.py" \
+    --dataset "$ds" --mode budget --fold "$k" --n "$n" --work "$W" || exit 1
+fi
+if [[ ! -s $W/prepared.json ]]; then
+  ALLOW_USER_SITE=1 bash "$S/tools/cpu_unit.sh" "rgc-prep-${ds:0:3}$k" 6 16 "$PY" -u "$S/tools/run_scsemi_paired.py" \
+    --work "$W" --phase prepare --device cpu --threads 6 --reuse-from "$A" || exit 1
+fi
+r=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['representatives'][0]['sample_id'])" "$W/inputs/inputs_manifest.json")
+[[ -s $A/scsemi_project/models/fastreconst2_$r.receipt.json ]] || { echo "CV run lacks the checkpoints of $r" >&2; exit 1; }
+if [[ ! -s $W/scsemi_project/models/fastreconst2_$r.receipt.json ]]; then
+  until bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh" && bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh"; do
+    sleep 120
+  done
+  "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+    OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=4 PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 \
+    "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase pretrain --device cuda:0 --threads 4 --max-reps 1 \
+    --reuse-from "$A" >> "$W/gpu.log" 2>&1 < /dev/null || { echo "GPU pretrain failed (see $W/gpu.log)" >&2; exit 1; }
+fi
+ALLOW_USER_SITE=1 bash "$S/tools/cpu_unit.sh" "rgc-cmp-${ds:0:3}$k" 2 8 "$PY" -u "$S/tools/compare_runs.py" "$OUT" "$W" "$A"
+rc=$?
+rm -f "$W"/scsemi_project/sample_sc/*.h5ad "$W"/scsemi_project/geneset_scores/*.npy
+python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print('reuse == fresh:', d['all_identical'], d['items'])" "$OUT"
+exit $rc

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

@@ -0,0 +1,233 @@
+#!/usr/bin/env bash
+# scSemiProfiler paired-baseline queue for this host, one split at a time (style of ../tools/run_queue.sh).
+#   queue line:  MODE|DATASET|SPLIT[|OPTIONS]      MODE fewshot (SPLIT = draw) or cv (SPLIT = fold)
+#                OPTIONS (comma list): clean_sample_sc = after the split's NPZ is exported AND validated, delete
+#                scsemi_project/sample_sc/*.h5ad (dense upstream cell graphs, ~1.5 GB per Giroux representative;
+#                their sha256 stay in prepared.json)
+# Per split:
+#   1. done check: generated NPZ + receipt + passing <npz>.validation.json -> skipped
+#   2. CPU units (tools/cpu_unit.sh, ml.slice, <= 6 threads, MemoryMax <= 16G): input build, upstream prepare
+#   3. GPU steps, each after the thermal gate and gpu_usable.sh, each through $HOME/.local/bin/ml-run (ml.slice,
+#      shared GPU lock): pretrain CHUNK_REPS representatives per call, then CHUNK_TARGETS targets per call, until
+#      status.json says complete.  Per-target runtime is in work/.../shards/<target>.json and events.jsonl.
+#   4. CPU units: export (adapter) + independent validation; optional scoring (SCORE=1, benchmark scorer)
+# A failure is logged, the split's partial outputs are preserved (no retry, no cleanup) and the queue moves on.
+#   env: QUEUE (required), MAX_WAIT_H (24), CHUNK_REPS (2), CHUNK_TARGETS (12), SCORE (0), SCSEMI_PY (host default)
+#        SMOKE_CPU=1: queue-logic test on "smoke|DATASET|DRAW|OPTIONS|T1,T2,.." lines only (2 reps x 300 cells, 1-2 epochs,
+#        CPU units instead of ml-run, outputs under scsemi/smoke/queue/); never touches the GPU
+#        PREP_ONLY=1: CPU steps only (input build + upstream prepare), no GPU, no export.  Safe to run while the GPU
+#        queue runs: every split is processed under an exclusive lock (work/.../.split.lock, waits up to MAX_WAIT_H).
+#        PREP_MEM (16): MemoryMax GiB of the upstream-prepare CPU unit (cpu_unit.sh caps it; see README memory note)
+# Added 2026-10-02 (opt-in; lines and env without them behave exactly as before):
+#   budget|DATASET|FOLD|OPTIONS|N : equal-pair-budget split (representatives = runs/<ds>/fold<k>/lora_n<N>/RUN.json
+#                train + inner-val rows; targets = fold k's rows) -> generated/<ds>/fold<k>/scsemi_n<N>__raw.npz
+#   OPTIONS lean_hvset   : prepare selects hvset with tools/lean_hvset.py (output-identical, one representative in
+#                          memory; needed for CV folds).  Passed to every wrapper call of the split (run binding).
+#           reuse_cv     : (budget lines) reuse the hvset and pretraining of work/<ds>/cv/fold<k> (--reuse-from); a CPU
+#                          'link' unit hard-links its checkpoints; GPU pretraining then runs only for a representative
+#                          whose source checkpoint is missing, and only with REUSE_ALLOW_PRETRAIN=1 (source seeds)
+#           clean_prepared: like clean_sample_sc, and also delete scsemi_project/geneset_scores/*.npy (cells x 2,922
+#                          float64, 11 GB per sepsis CV fold; sha256 kept in prepared.json, re-derivable)
+#           offload      : after export + validation, move scsemi_project/models/* and inputs/rep_sc.h5ad to spark-0110
+#                          (tools/offload_work.sh: same absolute paths, sha-verified; receipts and manifests stay)
+#   offload|DATASET|cv   : move work/<ds>/cv/fold* models + inputs to spark-0110 once every budget split of <ds> is done
+#   MIN_FREE_GIB (0 = off): before a split's input build and CPU prepare (where its prepared cell graphs and
+#                          gene-set scores are written), wait (MAX_WAIT_H) until $S's filesystem has this many GiB free
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+export DBUS_SESSION_BUS_ADDRESS="${DBUS_SESSION_BUS_ADDRESS:-unix:path=$XDG_RUNTIME_DIR/bus}"
+M8=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion
+T=$M8/plans/paired_finetune_intradataset_20260927
+S=$T/scsemi
+case "$(hostname -s)" in
+  spark-fa6b) PYD=$M8/plans/immicro_scsemi_comparison_20260927/runtime_env/bin/python; USERSITE=1 ;;   # server_1: frozen env
+  spark-0110) PYD=$S/runtime_env/bin/python; USERSITE=0 ;;                                            # server_2: equivalent venv
+  *) echo "unknown host $(hostname -s)" >&2; exit 2 ;;
+esac
+PY=${SCSEMI_PY:-$PYD}
+SPY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python     # benchmark scorer env (both hosts)
+QUEUE="${QUEUE:?QUEUE}"; MAX_WAIT_H="${MAX_WAIT_H:-24}"; CHUNK_REPS="${CHUNK_REPS:-2}"; CHUNK_TARGETS="${CHUNK_TARGETS:-12}"
+SCORE="${SCORE:-0}"; SMOKE_CPU="${SMOKE_CPU:-0}"; PREP_ONLY="${PREP_ONLY:-0}"; PREP_MEM="${PREP_MEM:-16}"
+MIN_FREE_GIB="${MIN_FREE_GIB:-0}"; REUSE_ALLOW_PRETRAIN="${REUSE_ALLOW_PRETRAIN:-0}"
+mkdir -p "$S/logs"
+LOG=$S/logs/queue_$(basename "$QUEUE" .txt)_$(hostname -s)_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+gate() {
+  local verdict usable
+  if [[ $SMOKE_CPU == 1 ]]; then echo "smoke: CPU only, no GPU gate"; return; fi
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") \
+        && usable=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  echo "$verdict; GPU $usable"
+}
+cpu() {   # cpu NAME THREADS MEMMAX CMD...   (waits for the memory floor instead of failing on it)
+  local mem=$3
+  until (( $(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo) >= 32 + mem )); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: memory floor not met within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 120
+  done
+  ALLOW_USER_SITE=${US:-$USERSITE} bash "$S/tools/cpu_unit.sh" "$@" >> "$LOG" 2>&1 < /dev/null
+}
+st() { python3 -c "import json,sys;print(json.load(open(sys.argv[1]))[sys.argv[2]])" "$1/status.json" "$2" 2>/dev/null; }
+disk() {   # disk NOTE : wait until MIN_FREE_GIB GiB are free on $S (no-op when MIN_FREE_GIB is 0)
+  (( MIN_FREE_GIB > 0 )) || return 0
+  local free warned=0
+  while free=$(df -B1G --output=avail "$S" | tail -1 | tr -dc '0-9'); (( free < MIN_FREE_GIB )); do
+    (( warned )) || { log "disk: ${free} GiB free < MIN_FREE_GIB ${MIN_FREE_GIB} before $1; waiting"; warned=1; }
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: disk below ${MIN_FREE_GIB} GiB within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 300
+  done
+  (( warned )) && log "disk: ${free} GiB free; continuing"
+  return 0
+}
+gpu() {   # gpu WORK PHASE EXTRA...
+  local W=$1 phase=$2; shift 2
+  if [[ $SMOKE_CPU == 1 ]]; then   # queue-logic test: same wrapper, CPU, reduced epochs, never ml-run
+    cpu "smk-$phase" 4 8 "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase "$phase" --device cpu --smoke --threads 4 "$@"
+    return
+  fi
+  local ns=
+  [[ $USERSITE == 1 ]] || ns=PYTHONNOUSERSITE=1
+  "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+    OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=4 PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 $ns \
+    "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase "$phase" --device cuda:0 --threads 4 "$@" \
+    >> "$W/gpu.log" 2>&1 < /dev/null
+}
+n_fail=0
+fail() { n_fail=$((n_fail+1)); log "WARN: $*"; }
+log "queue $QUEUE on $(hostname -s); python $PY; chunks reps=$CHUNK_REPS targets=$CHUNK_TARGETS; score=$SCORE; smoke_cpu=$SMOKE_CPU"
+while IFS= read -r line; do
+  [[ -z "${line// }" || "$line" == \#* ]] && continue
+  IFS='|' read -r mode ds j opts extra <<< "$line"
+  SMK=()
+  case $mode in
+    fewshot) W=$S/work/$ds/fewshot_n5/draw$j; OUT=$T/generated/$ds/fewshot_n5/draw$j/scsemi5__raw.npz; ARM=scsemi5
+             SC=$T/scores/$ds/fewshot_n5/draw${j}_scsemi5; DON=$T/data/$ds/fewshot_n5/draw$j/test_samples.txt
+             imode=fewshot; sflag=(--draw "$j") ;;
+    cv)      W=$S/work/$ds/cv/fold$j; OUT=$T/generated/$ds/fold$j/scsemi__raw.npz; ARM=scsemi
+             SC=$T/scores/$ds/fold${j}_scsemi; DON=; imode=cv; sflag=(--fold "$j") ;;
+    budget)  [[ $extra =~ ^[0-9]+$ ]] || { fail "budget line needs N in field 5: $line"; continue; }
+             W=$S/work/$ds/budget/fold$j/n$extra; OUT=$T/generated/$ds/fold$j/scsemi_n${extra}__raw.npz
+             ARM=scsemi_n$extra; SC=; DON=; imode=budget; sflag=(--fold "$j" --n "$extra") ;;
+    offload) # offload|DATASET|cv : after the budget lines that reuse them, move the CV runs' models + rep_sc.h5ad to
+             # spark-0110 (tools/offload_work.sh; same absolute paths, sha-verified).  Refused while any budget output
+             # of the dataset is missing or unvalidated (their link phase reads the CV checkpoints).
+             [[ $SMOKE_CPU != 1 && $j == cv ]] || { fail "offload line not run: $line"; continue; }
+             pend=0; args=()
+             for k in 0 1 2 3 4; do
+               for b in "$T"/generated/"$ds"/fold$k/scsemi_n*__raw.npz; do
+                 [[ -e $b ]] || continue
+                 python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "${b%.npz}.validation.json" 2>/dev/null || pend=1
+               done
+               for n in 5 10 20 40; do
+                 [[ -d $S/work/$ds/budget/fold$k/n$n ]] && [[ ! -s $T/generated/$ds/fold$k/scsemi_n${n}__raw.validation.json ]] && pend=1
+               done
+               args+=("$T/generated/$ds/fold$k/scsemi__raw.validation.json" "$S/work/$ds/cv/fold$k")
+             done
+             (( pend )) && { fail "$ds: a budget split is unfinished; CV runs kept for its link phase ($line)"; continue; }
+             log "$ds: offloading the CV runs' models and inputs to spark-0110"
+             bash "$S/tools/offload_work.sh" "${args[@]}" >> "$LOG" 2>&1 || fail "$ds: offload incomplete (local files kept where unverified)"
+             continue ;;
+    smoke)   [[ $SMOKE_CPU == 1 ]] || { fail "smoke line needs SMOKE_CPU=1: $line"; continue; }
+             # smoke|DS|SPLIT|OPTS|T1,T2[|MODE|N|REP_IDS]: MODE fewshot (default, as before), cv or budget
+             IFS='|' read -r stg smode sn sreps <<< "$extra"
+             smode=${smode:-fewshot}; SMK=(--smoke)
+             if [[ $smode == fewshot ]]; then
+               W=$S/smoke/queue/${ds}_draw$j; OUT=$W/generated/scsemi5__raw.npz; ARM=scsemi5
+               sflag=(--draw "$j" --smoke-reps 2 --smoke-cells 300 --smoke-targets "$stg")
+             else
+               W=$S/smoke/queue/${ds}_${smode}$j${sn:+_n$sn}; OUT=$W/generated/scsemi__raw.npz; ARM=scsemi
+               sflag=(--fold "$j" ${sn:+--n "$sn"} --smoke-cells 300 --smoke-targets "$stg")
+               if [[ -n $sreps ]]; then sflag+=(--smoke-rep-ids "$sreps"); else sflag+=(--smoke-reps 2); fi
+             fi
+             SC=$W/score; DON=$W/targets.txt; imode=$smode
+             mkdir -p "$W"; tr ',' '\n' <<< "$stg" > "$DON" ;;
+    *) fail "unknown line: $line"; continue ;;
+  esac
+  [[ $SMOKE_CPU == 1 && $mode != smoke ]] && { fail "SMOKE_CPU=1 runs smoke lines only: $line"; continue; }
+  tag="$ds/$mode$j"; uid="${ds:0:3}-$mode$j"
+  [[ $mode == budget ]] && { tag="$ds/budget${j}_n$extra"; uid="${ds:0:3}-b${j}n$extra"; }
+  WARGS=(); REUSE=0
+  [[ ",$opts," == *",lean_hvset,"* ]] && WARGS+=(--lean-hvset)
+  if [[ ",$opts," == *",reuse_cv,"* ]]; then
+    [[ $mode == budget || ( $mode == smoke && $imode == budget ) ]] || { fail "reuse_cv is for budget lines: $line"; continue; }
+    if [[ $mode == smoke ]]; then WARGS+=(--reuse-from "$S/smoke/queue/${ds}_cv$j"); else WARGS+=(--reuse-from "$S/work/$ds/cv/fold$j"); fi
+    REUSE=1
+  fi
+  mkdir -p "$W"
+  exec 9>"$W/.split.lock"          # re-opening fd 9 releases the previous split's lock
+  flock -w $((MAX_WAIT_H * 3600)) 9 || { fail "$tag: split lock held by another queue for ${MAX_WAIT_H} h"; continue; }
+  VAL=${OUT%.npz}.validation.json
+  if [[ -s $VAL ]] && python3 -c "import json,sys;sys.exit(0 if json.load(open(sys.argv[1]))['passed'] else 1)" "$VAL"; then
+    log "$tag: exported + validated already; skipped"
+  else
+    mkdir -p "$W"
+    if [[ ! -s $W/inputs/inputs_manifest.json ]]; then
+      disk "$tag input build"
+      log "$tag: building inputs (CPU unit)"
+      cpu "in-$uid" 4 12 "$PY" -u "$S/tools/prepare_draw_inputs.py" --dataset "$ds" --mode "$imode" "${sflag[@]}" --work "$W" \
+        || { fail "$tag: input build failed"; continue; }
+    fi
+    if [[ ! -s $W/prepared.json ]]; then
+      disk "$tag prepare"
+      log "$tag: upstream prepare (initsetup + assignment + scprocess, CPU unit)${WARGS[*]:+ [${WARGS[*]}]}"
+      cpu "prep-$uid" 6 "$PREP_MEM" "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase prepare --device cpu --threads 6 "${SMK[@]}" "${WARGS[@]}" \
+        || { fail "$tag: prepare failed (see $W/events.jsonl)"; continue; }
+    fi
+    if [[ $PREP_ONLY == 1 ]]; then log "$tag: CPU-prepared (PREP_ONLY; GPU steps left to the GPU queue)"; continue; fi
+    if (( REUSE )) && [[ "$(st "$W" pretrain_complete)" != True ]]; then
+      log "$tag: linking the source run's pretrain checkpoints (CPU unit)"
+      cpu "lnk-$uid" 2 4 "$PY" -u "$S/tools/run_scsemi_paired.py" --work "$W" --phase link --device cpu --threads 2 "${SMK[@]}" "${WARGS[@]}" \
+        || { fail "$tag: link failed (see $W/events.jsonl)"; continue; }
+      log "$tag: pretrain checkpoints after link: $(st "$W" reps_pretrained)/$(st "$W" n_reps)"
+      if [[ "$(st "$W" pretrain_complete)" != True && $REUSE_ALLOW_PRETRAIN != 1 ]]; then
+        fail "$tag: source run lacks pretrain checkpoints; REUSE_ALLOW_PRETRAIN=1 pretrains them with the source seeds"; continue
+      fi
+    fi
+    ok=1
+    while [[ "$(st "$W" pretrain_complete)" != True ]]; do
+      before=$(st "$W" reps_pretrained)
+      g=$(gate) || { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+      log "$tag: pretrain ${before}/$(st "$W" n_reps) reps; next $CHUNK_REPS ($g)"
+      gpu "$W" pretrain --max-reps "$CHUNK_REPS" "${WARGS[@]}" || { fail "$tag: pretrain step failed (see $W/gpu.log, $W/events.jsonl)"; ok=0; break; }
+      [[ "$(st "$W" reps_pretrained)" != "$before" ]] || { fail "$tag: pretrain made no progress"; ok=0; break; }
+    done
+    (( ok )) || continue
+    while [[ "$(st "$W" infer_complete)" != True ]]; do
+      before=$(st "$W" targets_done)
+      g=$(gate) || { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+      log "$tag: infer ${before}/$(st "$W" n_targets) targets; next $CHUNK_TARGETS ($g)"
+      gpu "$W" infer --max-targets "$CHUNK_TARGETS" "${WARGS[@]}" || { fail "$tag: infer step failed (see $W/gpu.log, $W/events.jsonl)"; ok=0; break; }
+      [[ "$(st "$W" targets_done)" != "$before" ]] || { fail "$tag: infer made no progress"; ok=0; break; }
+    done
+    (( ok )) || continue
+    if [[ ! -s $OUT ]]; then
+      cpu "exp-$uid" 2 16 "$PY" -u "$S/tools/export_npz.py" --work "$W" --out "$OUT" || { fail "$tag: export failed"; continue; }
+    fi
+    cpu "val-$uid" 2 16 "$PY" -u "$S/tools/validate_export.py" --work "$W" --npz "$OUT" || { fail "$tag: validation failed ($VAL)"; continue; }
+    log "$tag: exported + validated: $(python3 -c "import json,sys;d=json.load(open(sys.argv[1]));print('targets',d['bulks'],'median target s %.1f'%d['median_target_seconds'],'total target s %.0f'%d['total_target_seconds'])" "${OUT%.npz}.log")"
+    if [[ ",$opts," == *",clean_sample_sc,"* || ",$opts," == *",clean_prepared,"* ]]; then
+      rm -f "$W"/scsemi_project/sample_sc/*.h5ad && log "$tag: removed sample_sc/*.h5ad (sha256 kept in prepared.json)"
+    fi
+    if [[ ",$opts," == *",clean_prepared,"* ]]; then
+      rm -f "$W"/scsemi_project/geneset_scores/*.npy && log "$tag: removed geneset_scores/*.npy (sha256 kept in prepared.json)"
+    fi
+    if [[ ",$opts," == *",offload,"* && $SMOKE_CPU != 1 ]]; then
+      bash "$S/tools/offload_work.sh" "$VAL" "$W" >> "$LOG" 2>&1 && log "$tag: models + rep_sc.h5ad moved to spark-0110" \
+        || fail "$tag: offload incomplete (local files kept where unverified)"
+    fi
+  fi
+  if [[ $SCORE == 1 && $PREP_ONLY != 1 && $mode != cv && $mode != budget && -s $VAL && ! -s $SC/summary.json ]]; then
+    read -r -a cargs <<< "$(bash "$T/tools/contrast_args.sh" "$ds")"
+    log "$tag: scoring arm $ARM -> $SC"
+    mkdir -p "$SC"
+    US=0 cpu "sc-$uid" 6 16 "$SPY" -u "$T/tools/score_ft.py" --dataset "$ds" --out "$SC" --threads 6 \
+      --donors "$DON" "${cargs[@]}" --arm "$ARM=$OUT" || fail "$tag: scoring failed"
+  fi
+done < "$QUEUE"
+exec 9>&-
+log "queue finished: failed=$n_fail"
+(( n_fail == 0 ))