Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/pause_scsemi_for_loco.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# User decision 2026-10-03 00:40 KST: LOCO first. Pause the scSemiProfiler CV / budget queue (scsemi-queue-cvb-s1) at a
+# clean point and restart it, with its original settings, once both LOCO queues have finished.
+#   1. wait until no scSemiProfiler GPU step (mljob running run_scsemi_*) and no scsemi-* CPU step is running
+#   2. stop scsemi-queue-cvb-s1 (it resumes split by split from its receipts, see scsemi/README.md)
+#   3. wait until loco-queue-s1 (server_1) and loco-queue-s2 (server_2) are both inactive
+#   4. start scsemi-queue-cvb-s1 again with QUEUE / MAX_WAIT_H / MIN_FREE_GIB as originally launched (2026-10-02 09:28)
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+S=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_finetune_intradataset_20260927/scsemi
+log() { echo "$(date -Is) $*"; }
+busy() {
+  local u
+  for u in $(systemctl --user list-units --type=service --state=running --no-legend | awk '{print $1}'); do
+    case $u in
+      mljob*) systemctl --user show "$u" -p ExecStart --value | grep -q 'run_scsemi' && return 0 ;;
+      scsemi-queue*) ;;
+      scsemi-*) return 0 ;;
+    esac
+  done
+  return 1
+}
+log "waiting for the current scSemiProfiler step to end"
+while busy; do sleep 5; done
+systemctl --user stop scsemi-queue-cvb-s1
+log "scsemi-queue-cvb-s1 stopped (paused for LOCO); last queue log lines:"
+grep -v '^unit' "$(ls -t "$S"/logs/queue_server1_cv_budget*.log | head -1)" | tail -2
+while systemctl --user is-active --quiet loco-queue-s1 \
+      || ssh -n spark-0110 'XDG_RUNTIME_DIR=/run/user/$(id -u) systemctl --user is-active loco-queue-s2' 2>/dev/null | grep -q '^active'; do
+  sleep 300
+done
+systemctl --user reset-failed scsemi-queue-cvb-s1 2>/dev/null
+systemd-run --user --unit=scsemi-queue-cvb-s1 --setenv=QUEUE="$S/queues/server1_cv_budget_20261002.txt" \
+  --setenv=MAX_WAIT_H=480 --setenv=MIN_FREE_GIB=80 /bin/bash "$S/tools/run_queue_scsemi.sh"
+log "LOCO queues finished; scsemi-queue-cvb-s1 restarted"

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/run_loco_queue.sh

@@ -0,0 +1,180 @@
+#!/usr/bin/env bash
+# Cross-cohort (LOCO) queue: the same queue file runs on server_1 and server_2; each line is one unit that a host
+# claims before it starts (atomic mkdir in claims/ on server_1, so a unit never runs on both hosts).
+#   zs|COHORT|K                      base model on data/<cohort>/test_raw_K<K>.npz   -> generated/<cohort>/zs_K<K>.npz
+#   xcal|SPLIT|K                     base model on splits/<split>/test_xcal_K<K>.npz -> generated/<held>/<split>/xcal_K<K>.npz
+#   loco|SPLIT|K|TAG|MODE|LR[|extra] fine-tune (ft_sdd_multi.py) -> runs/<split>/K<K>/<TAG>/, then sample the held-out
+#                                    cohort's test_raw_K<K>.npz -> generated/<held>/<split>/K<K>_<TAG>.npz; with --block
+#                                    (step saturation) every milestone checkpoint -> .../K<K>_<TAG>_s<step>.npz
+# Every GPU step goes through ml-run (ml.slice, shared GPU lock) after the thermal gate and gpu_usable.sh (shared with
+# the scSemiProfiler queue: when only this user's ml.slice job holds the GPU, ml-run waits on the lock, so the two
+# queues alternate and never overlap). Sampling: the sampler call of utility_studies sample_queue.sh (DDIM 50,
+# Bernoulli read-out, seed 20260927, 1,500 cells per bulk), behind this queue's gate.
+# On server_2 every finished unit is copied back to the same absolute paths on server_1 (sha-checked).
+# A host claims a unit only after its GPU gate passes. A failed unit is marked FAILED in its claim and not retried;
+# two failures in a row stop the queue.
+#   env: QUEUE (required), REVERSE (0; 1 = walk the queue from the end), MAX_WAIT_H (480)
+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
+P=$M8/plans/paired_crosscohort_20261002
+SQ=$M8/plans/utility_studies_final6k_20260925/tools/sample_queue.sh
+BASE_CKPT=$M8/runs/f01_6k_1x_seed20260627/checkpoint_epoch_016.pt
+BASE_SHA=8c7cd0e83e2bc19fe03dfcbc084919a1e2f61be8cc8bc12f4caf543dfda91633
+SEED=20260927
+COORD=spark-fa6b
+case "$(hostname -s)" in
+  spark-fa6b) HOST=server_1; PY=/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python ;;
+  spark-0110) HOST=server_2; PY=/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python ;;
+  *) echo "unknown host" >&2; exit 2 ;;
+esac
+QUEUE="${QUEUE:?QUEUE}"; REVERSE="${REVERSE:-0}"; MAX_WAIT_H="${MAX_WAIT_H:-480}"
+mkdir -p "$P/logs"
+LOG=$P/logs/loco_queue_$(basename "$QUEUE" .txt)_${HOST}_$(date +%Y%m%dT%H%M%S).log
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+start=$(date +%s)
+
+on_coord() { if [[ $HOST == server_1 ]]; then bash -c "$1"; else ssh -n "$COORD" "$1"; fi; }
+claim() {   # claim KEY -> 0 if this host now owns the unit
+  on_coord "mkdir -p '$P/claims' && mkdir '$P/claims/$1' 2>/dev/null && echo '$HOST $(date -Is)' > '$P/claims/$1/OWNER'"
+}
+mark() { on_coord "echo '$HOST $(date -Is) ${3:-}' > '$P/claims/$1/$2'"; }
+usable_or_own() {
+  # gpu_usable.sh (free GPU, or a foreign process idle at <= 5 %), or else: every compute process on the GPU is this
+  # user's own job inside ml.slice (the scSemiProfiler queue holding the shared lock). In that case ml-run below blocks
+  # on the shared lock and the two queues take turns, never overlapping. Anything else (another user's process at
+  # work, memory below 32 GiB, guard inactive) waits.
+  local r; r=$(bash "$M8/plans/arch_ablation_6k_20260913/tools/gpu_usable.sh" 2>/dev/null) && { echo "$r"; return 0; }
+  systemctl --user is-active --quiet ml-memory-guard.service || return 1
+  local avail; avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo); (( avail >= 32 )) || return 1
+  local pids p; pids=$(nvidia-smi --query-compute-apps=pid --format=csv,noheader | tr -d ' ')
+  [[ -n $pids ]] || return 1
+  for p in $pids; do
+    [[ "$(stat -c %U "/proc/$p" 2>/dev/null)" == "$(id -un)" ]] && grep -q '/ml.slice/' "/proc/$p/cgroup" 2>/dev/null || return 1
+  done
+  echo "own ml.slice job on the GPU; waiting on the shared lock"
+}
+gate() {
+  until verdict=$(bash "$M8/plans/floor01_campaign_20260923/tools/thermal_guard.sh") && usable=$(usable_or_own); do
+    (( $(date +%s) - start > MAX_WAIT_H * 3600 )) && { log "ABORT: no usable GPU within ${MAX_WAIT_H} h"; exit 1; }
+    sleep 60
+  done
+  echo "$verdict; GPU $usable"
+}
+copy_back() {  # server_2 -> server_1, same absolute paths; NPZ checked against its receipt's sha256
+  [[ $HOST == server_1 ]] && return 0
+  local f
+  for f in "$@"; do
+    [[ -e $f ]] || continue
+    ssh -n "$COORD" "mkdir -p '$(dirname "$f")'" && rsync -a "$f" "$COORD:$(dirname "$f")/" || return 1
+  done
+  return 0
+}
+yield_gpu() {  # after each GPU step: if another of this user's GPU queues is active, pause longer than its 120 s gate
+  # poll so that it gets the next turn on the shared lock (the queues alternate instead of one starving the other)
+  local u
+  for u in $(systemctl --user list-units --type=service --state=active --no-legend 2>/dev/null | awk '{print $1}' \
+             | grep -E '^scsemi-queue'); do
+    log "yield: $u is active; pausing 150 s"; sleep 150; return 0
+  done
+}
+sample() {  # sample TAG CKPT CKPT_SHA COND OUT -- the sampler call of sample_queue.sh ($SQ), with this queue's gate
+  local tag=$1 ck=$2 sha=$3 cond=$4 out=$5 rec=${5%.npz}.log err=${5%.npz}.err
+  if [[ -s $rec && -s $out ]]; then log "$tag already sampled; skipped"; return 0; fi
+  [[ -s $cond ]] || { log "WARN: $tag condition missing: $cond"; return 1; }
+  [[ "$(sha256sum "$ck" | cut -d' ' -f1)" == "$sha" ]] || { log "WARN: $tag checkpoint sha differs"; return 1; }
+  mkdir -p "$(dirname "$out")"
+  log "--- sample $tag seed=$SEED ($(gate))"
+  if "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+       PYTHONPATH="$M8/src" OMP_NUM_THREADS=4 "$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 sampled: $(python3 -c "import json;d=json.load(open('$rec'));print('zero_frac %.4f' % d.get('generated_zero_fraction',-1), d.get('output_sha256','')[:12])" 2>/dev/null)"
+  else
+    log "WARN: $tag sampling failed (see $err)"; rm -f "$rec"; yield_gpu; return 1
+  fi
+  yield_gpu
+  [[ -s $rec && -s $out ]]
+}
+held_of() { python3 -c "import json;print(json.load(open('$P/splits/$1.json'))['held_out'])"; }
+
+mapfile -t LINES < <(grep -v -e '^\s*$' -e '^#' "$QUEUE")
+[[ $REVERSE == 1 ]] && mapfile -t LINES < <(printf '%s\n' "${LINES[@]}" | tac)
+log "queue=$QUEUE host=$HOST units=${#LINES[@]} reverse=$REVERSE py=$PY"
+fails=0; n_done=0
+for line in "${LINES[@]}"; do
+  IFS='|' read -r kind a1 a2 a3 a4 a5 extra <<< "$line"
+  case $kind in
+    zs)   key="zs_${a1}_K${a2}" ;;
+    xcal) key="xcal_${a1}_K${a2}" ;;
+    loco) key="loco_${a1}_K${a2}_${a3}" ;;
+    *) log "WARN: unknown line: $line"; continue ;;
+  esac
+  # wait for a usable GPU before claiming, so a host that cannot run now never holds a unit the other host could run
+  on_coord "test -d '$P/claims/$key'" && continue
+  gate > /dev/null
+  claim "$key" || continue
+  unit_t0=$(date +%s)
+  log "=== $key claimed"
+  ok=0
+  if [[ $kind == zs ]]; then
+    out=$P/generated/$a1/zs_K$a2.npz
+    sample "$key" "$BASE_CKPT" "$BASE_SHA" "$P/data/$a1/test_raw_K$a2.npz" "$out" && ok=1
+    files=("$out" "${out%.npz}.log" "${out%.npz}.err")
+  elif [[ $kind == xcal ]]; then
+    held=$(held_of "$a1"); out=$P/generated/$held/$a1/xcal_K$a2.npz
+    sample "$key" "$BASE_CKPT" "$BASE_SHA" "$P/splits/$a1/test_xcal_K$a2.npz" "$out" && ok=1
+    files=("$out" "${out%.npz}.log" "${out%.npz}.err")
+  else
+    split=$a1 K=$a2 tag=$a3 mode=$a4 lr=$a5
+    held=$(held_of "$split"); run=$P/runs/$split/K$K/$tag; out=$P/generated/$held/$split/K${K}_$tag.npz
+    mkdir -p "$run"
+    if [[ ! -s $run/RUN.json ]]; then
+      log "--- train $split K=$K $tag mode=$mode lr=$lr ($(gate))"
+      # shellcheck disable=SC2086
+      "$HOME/.local/bin/ml-run" /usr/bin/env CUDA_VISIBLE_DEVICES=0 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
+        OMP_NUM_THREADS=4 PYTHONUNBUFFERED=1 "$PY" -u "$P/tools/ft_sdd_multi.py" --checkpoint "$BASE_CKPT" \
+        --checkpoint-sha "$BASE_SHA" --split "$P/splits/$split.json" --k "$K" --mode "$mode" --lr "$lr" \
+        --out-dir "$run" ${extra//|/ } >> "$run/train.log" 2>&1
+      yield_gpu
+    fi
+    files=("$run/RUN.json" "$run/history.json" "$run/train.log" "$run/checkpoint_ft.pt")
+    if [[ -s $run/RUN.json ]]; then
+      sha=$(python3 -c "import json;print(json.load(open('$run/RUN.json'))['checkpoint_sha256'])")
+      log "train $key: $(python3 -c "import json;d=json.load(open('$run/RUN.json'));print('selected step',d['selected_step'],'of',d['steps_run'],'stop',d.get('stop_reason'),'inner-val %.5f (pre %.5f)'%(d['selected_inner_val_loss'],d['pretrained_inner_val_loss']),'%.0f s'%d['wall_seconds'])")"
+      ms=$(python3 -c "import json;d=json.load(open('$run/RUN.json'));print(' '.join('%d:%s' % (m['milestone_step'], m['checkpoint_sha256']) for m in d.get('milestones') or []))")
+      if [[ -n $ms ]]; then
+        # step-saturation runs: sample every milestone checkpoint (best-so-far at each block end) -> K<K>_<tag>_s<step>
+        ok=1; files+=("$run/milestones.json")
+        for x in $ms; do
+          st=${x%%:*}; msha=${x#*:}; out=$P/generated/$held/$split/K${K}_${tag}_s${st}.npz
+          sample "${key}_s${st}" "$run/checkpoint_ft_s${st}.pt" "$msha" "$P/data/$held/test_raw_K$K.npz" "$out" || ok=0
+          files+=("$run/checkpoint_ft_s${st}.pt" "$out" "${out%.npz}.log" "${out%.npz}.err")
+        done
+      else
+        sample "$key" "$run/checkpoint_ft.pt" "$sha" "$P/data/$held/test_raw_K$K.npz" "$out" && ok=1
+        files+=("$out" "${out%.npz}.log" "${out%.npz}.err")
+      fi
+    else
+      log "WARN: train $key failed (see $run/train.log)"
+    fi
+  fi
+  if (( ok )); then
+    copy_back "${files[@]}" || { log "WARN: $key copy to server_1 failed; outputs kept on $HOST"; ok=0; }
+  fi
+  if (( ok )); then
+    mark "$key" DONE "$(python3 -c "import json;print(json.load(open('${out%.npz}.log'))['output_sha256'])")"
+    log "=== $key done"; fails=0; n_done=$((n_done+1))
+  else
+    mark "$key" FAILED; log "=== $key FAILED"; fails=$((fails+1))
+    # host policy: after a memory-guard stop, inspect before any further GPU work -> never move on to the next unit
+    if journalctl -t ml-memory-guard --since "@$unit_t0" --no-pager 2>/dev/null | grep -q "stopping ml.slice"; then
+      log "ABORT: the memory guard stopped ml.slice during $key; queue stopped for inspection (no further units)"
+      exit 1
+    fi
+    (( fails >= 2 )) && { log "ABORT: two failed units in a row"; exit 1; }
+  fi
+done
+log "queue finished on $HOST: units done here=$n_done"

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/score_pending.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# Score every finished LOCO arm on server_1 (CPU), one arm per score_ft.py call, as soon as it exists.
+# Each call scores the held-out cohort's usable samples (data/<cohort>/usable_samples.txt) against the cohort's frozen
+# reference (scoring_cache of the within-cohort benchmark), so calls are comparable with each other and with that
+# benchmark's pooled 5-fold call (same donors, same reference; checked by aggregate_loco.py).
+#   arms: zs_K1000 (the within-cohort benchmark's zero-shot on all usable rows; same model, sampler, seed and bulk
+#         arrays as zs_K2000 apart from K), zs_K2000, xcal_K<K>, loco_<tag>_K<K>, and with training-only cohorts
+#         added to the pool (splits hoL_*) xcalL_K<K>, locoL_<tag>_K<K>
+#   out:  scores/<cohort>/<arm>/ ; Giroux also scores_nosex/giroux2022/<arm>/ (sex-linked genes excluded from the
+#         disease metrics, labels reused), as the deck reports Giroux
+# Runs until both LOCO queues (server_1 loco-queue-s1, server_2 loco-queue-s2) are inactive and nothing is pending.
+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
+P=$M8/plans/paired_crosscohort_20261002
+SRC=$M8/plans/paired_finetune_intradataset_20260927
+PY=/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python
+SEX=$SRC/data/sex_linked_genes/sex_linked_genes_exclude.csv
+COHORTS=(immicro ye2026_sepsis imperial_eskd giroux2022 ji2025_chili)
+LOG=$P/logs/score_pending_$(date +%Y%m%dT%H%M%S).log
+mkdir -p "$P/logs"
+log() { echo "$(date +%FT%T) $*" | tee -a "$LOG"; }
+
+zs1000() {  # the within-cohort benchmark's zero-shot NPZ (Imperial's lives on server_2: copied once, sha-checked)
+  local c=$1 f=$SRC/generated/$1/fewshot_n5/zs__raw_all.npz
+  if [[ -s $f ]]; then echo "$f"; return; fi
+  local d=$P/inputs_server2/$c; f=$d/zs__raw_all.npz
+  if [[ ! -s $f ]]; then
+    mkdir -p "$d" && rsync -a "spark-0110:$SRC/generated/$c/fewshot_n5/zs__raw_all.npz" \
+      "spark-0110:$SRC/generated/$c/fewshot_n5/zs__raw_all.log" "$d/" || { rm -f "$f"; return 1; }
+  fi
+  echo "$f"
+}
+arms_of() {  # prints "ARM NPZ" for every arm of cohort $1 whose NPZ and receipt exist
+  # split ho_<c>: arms xcal_K<K>, loco_<tag>_K<K>; split hoL_<c> (training pool + training-only cohorts such as
+  # Liu 2021, tools/prepare_loco_extra.py): arms xcalL_K<K>, locoL_<tag>_K<K>
+  local c=$1 f K tag b s suf
+  f=$(zs1000 "$c") && echo "zs_K1000 $f"
+  f=$P/generated/$c/zs_K2000.npz
+  [[ -s $f && -s ${f%.npz}.log ]] && echo "zs_K2000 $f"
+  for s in "ho_$c" "hoL_$c"; do
+    suf=""; [[ $s == hoL_* ]] && suf=L
+    for f in "$P/generated/$c/$s"/xcal_K*.npz "$P/generated/$c/$s"/K*_*.npz; do
+      [[ -s $f && -s ${f%.npz}.log ]] || continue
+      b=$(basename "$f" .npz)
+      if [[ $b == xcal_K* ]]; then echo "xcal${suf}_${b#xcal_} $f"
+      else K=${b%%_*}; tag=${b#*_}; echo "loco${suf}_${tag}_${K} $f"; fi
+    done
+  done
+}
+score_one() {  # cohort arm npz [extra args]
+  local c=$1 arm=$2 npz=$3; shift 3
+  local name=score-${c}-${arm}-$(date +%H%M%S)
+  local avail; avail=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
+  (( avail >= 56 )) || { log "MemAvailable $avail GiB < 56: $c $arm waits"; return 1; }
+  read -r -a cargs <<< "$(bash "$SRC/tools/contrast_args.sh" "$c")"
+  systemd-run --user --unit="$name" --working-directory="$P" --wait --collect --quiet \
+    -p MemoryMax=24G -p MemorySwapMax=0 -p CPUQuota=800% -p Nice=10 \
+    -p StandardOutput=append:"$P/logs/$name.log" -p StandardError=append:"$P/logs/$name.log" \
+    --setenv=CUDA_VISIBLE_DEVICES= --setenv=PYTHONNOUSERSITE=1 --setenv=PYTHONDONTWRITEBYTECODE=1 \
+    --setenv=PYTHONUNBUFFERED=1 --setenv=OMP_NUM_THREADS=8 --setenv=OPENBLAS_NUM_THREADS=8 \
+    --setenv=MKL_NUM_THREADS=8 --setenv=NUMBA_NUM_THREADS=8 \
+    "$PY" "$SRC/tools/score_ft.py" --dataset "$c" --threads 8 --donors "$P/data/$c/usable_samples.txt" \
+    --arm "$arm=$npz" "${cargs[@]}" "$@"
+}
+queues_active() {
+  systemctl --user is-active --quiet loco-queue-s1 && return 0
+  ssh -n spark-0110 'XDG_RUNTIME_DIR=/run/user/$(id -u) systemctl --user is-active loco-queue-s2' 2>/dev/null | grep -q '^active' && return 0
+  return 1
+}
+
+log "start"
+while true; do
+  active=0; queues_active && active=1
+  pending=0
+  for c in "${COHORTS[@]}"; do
+    while read -r arm npz; do
+      [[ -n $arm ]] || continue
+      out=$P/scores/$c/$arm
+      # a failed call leaves <out>.FAILED and is not retried (inspect logs/score-<cohort>-<arm>-*.log, then remove it)
+      if [[ ! -s $out/summary.json && ! -e $out.FAILED ]]; then
+        pending=1
+        log "score $c $arm"
+        if score_one "$c" "$arm" "$npz" --out "$out"; then log "scored $c $arm"
+        else log "WARN: scoring $c $arm failed (logs/score-$c-$arm-*.log)"; date -Is > "$out.FAILED"; fi
+      fi
+      nos=$P/scores_nosex/$c/$arm
+      if [[ $c == giroux2022 && -s $out/summary.json && ! -s $nos/summary.json && ! -e $nos.FAILED ]]; then
+        pending=1
+        mkdir -p "$(dirname "$nos")"
+        if score_one "$c" "$arm" "$npz" --out "$nos" --exclude-genes "$SEX" --reuse-labels "$out"; then
+          log "scored $c $arm (sex-linked genes excluded)"
+        else log "WARN: no-sex rescore $c $arm failed"; date -Is > "$nos.FAILED"; fi
+      fi
+    done < <(arms_of "$c")
+  done
+  # fully scored NPZs go to server_2 (same path, sha-checked; an Imperial set is ~6 GB): tools/offload_scored.sh
+  (( pending )) && bash "$P/tools/offload_scored.sh" >> "$P/logs/offload_scored.log" 2>&1
+  if (( ! active && ! pending )); then log "queues inactive and nothing pending: done"; break; fi
+  sleep 60
+done

paper-releases/pbisc-diffusion/updates/20261003T103040Z-crosscohort-k1000-saturation/diffusion/dataset/server_1/model8/plans/paired_crosscohort_20261002/tools/swap_runner_after_unit.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# One-off (2026-10-02): restart the server_1 LOCO runner with the current run_loco_queue.sh as soon as the unit it is
+# running finishes, without losing work: wait for "=== <KEY> done|FAILED" in its log, stop the runner, stop any LOCO GPU
+# job it had already started for the next unit, release that unit's fresh claim (no DONE / FAILED), start the runner.
+#   usage: swap_runner_after_unit.sh KEY LOG QUEUE
+set -uo pipefail
+export XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
+P=/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002
+key=$1 log=$2 queue=$3
+until grep -q -E "=== ${key} (done|FAILED)" "$log"; do sleep 2; done
+systemctl --user stop loco-queue-s1
+for u in $(systemctl --user list-units --type=service --state=running --no-legend | awk '{print $1}' | grep '^mljob'); do
+  systemctl --user show "$u" -p ExecStart --value | grep -q "paired_crosscohort_20261002" && { echo "stop $u"; systemctl --user stop "$u"; }
+done
+for d in "$P"/claims/*/; do
+  [[ -e $d/DONE || -e $d/FAILED || -e $d/STOPPED ]] && continue
+  grep -q '^server_1' "$d/OWNER" 2>/dev/null && { echo "release $(basename "$d")"; rm -rf "$d"; }
+done
+systemctl --user reset-failed loco-queue-s1 2>/dev/null
+systemd-run --user --unit=loco-queue-s1 --setenv=QUEUE="$queue" --setenv=MAX_WAIT_H=480 -p MemorySwapMax=0 \
+  /bin/bash "$P/tools/run_loco_queue.sh"
+echo "runner restarted $(date -Is)"