Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T124345Z-trunk4x-lora-sepsis-launch/diffusion/dataset/server_1/model8/plans/trunk4x_lora_sepsis_20261013/tools/ft_sdd_frozen.py

@@ -0,0 +1,503 @@
+#!/usr/bin/env python3
+"""Fine-tune the final PBISC-SDD model inside one paired dataset fold.
+
+Training pairs are (condition of row r, one retained cell of row r).  The condition comes from a condition NPZ
+written by prepare_dataset.py (real bulk or pseudobulk, fixed-depth policy) and goes through the checkpoint's own
+conditioner exactly as the standalone sampler does (sample_sdd_standalone.load_conditions), then
+condition_with_measurement_context(base, bulk_measurement_fraction, output_availability_mask).  The loss is the
+pretraining loss (SparseDataDiffusion.training_loss: measured-only value L2 + support BCE, self-conditioning),
+with bf16 autocast, AdamW and gradient clipping as in pretraining.
+
+Rows: fold k's test rows are never loaded.  Training rows = the other folds minus the inner-validation rows;
+inner-validation rows give a fixed-draw diffusion loss every --eval-every steps, and the EMA state with the lowest
+inner-validation loss is kept (early stopping with --patience evaluations).
+
+Modes (what is trainable):
+  full     every denoiser parameter
+  condenc  only denoiser.condition_encoder (the bulk -> context map)
+  lora     low-rank updates W = W0 + (alpha/r) B A on every nn.Linear of the denoiser (B starts at zero);
+           merged into the weights before saving
+
+Batches are donor-balanced: a row is drawn uniformly, then one of its cells uniformly.
+
+The output checkpoint keeps the input checkpoint's schema and self-contained keys, with model_state and
+ema_state.model_state set to the selected weights, so scripts/sample_sdd_standalone.py samples it unchanged.
+src/pbisc_sdd is sealed and is only imported.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch import nn
+import torch.nn.utils.parametrize as parametrize
+
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+for p in (M8 / "src", M8 / "scripts"):
+    if str(p) not in sys.path:
+        sys.path.insert(0, str(p))
+import sample_sdd_standalone as SS  # noqa: E402
+from pbisc_sdd.data import condition_with_measurement_context  # noqa: E402
+
+SCHEMA = "pbisc_sdd.ft_intradataset.run.v1"
+KEEP_KEYS = ("schema_version", "model_config", "diffusion_config", "value_scaler", "conditioner_state",
+             "gene_positions", "gene_ids", "gene_symbols", "gene_measurement_coverage",
+             "full_gene_measurement_coverage", "corpus_fingerprint", "experiment_config", "proportion_hint",
+             "training_contract")
+
+
+def sha256_file(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 log(msg: str) -> None:
+    print(f"{datetime.now().isoformat(timespec='seconds')} {msg}", flush=True)
+
+
+# ----------------------------------------------------------------------------------------------- LoRA
+class LoRADelta(nn.Module):
+    """Parametrization W -> W + scale * B @ A (B zero-initialised, so the start equals the pretrained W)."""
+
+    def __init__(self, out_features: int, in_features: int, rank: int, alpha: float) -> None:
+        super().__init__()
+        self.A = nn.Parameter(torch.empty(rank, in_features))
+        self.B = nn.Parameter(torch.zeros(out_features, rank))
+        nn.init.kaiming_uniform_(self.A, a=math.sqrt(5))
+        self.scale = float(alpha) / float(rank)
+
+    def forward(self, weight: torch.Tensor) -> torch.Tensor:
+        return weight + self.scale * (self.B @ self.A).to(dtype=weight.dtype)
+
+
+def add_lora(model: nn.Module, rank: int, alpha: float) -> list[str]:
+    names = []
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            delta = LoRADelta(module.out_features, module.in_features, rank, alpha).to(
+                device=module.weight.device, dtype=module.weight.dtype)
+            parametrize.register_parametrization(module, "weight", delta)
+            names.append(name)
+    return names
+
+
+def merge_lora(model: nn.Module) -> None:
+    for module in model.modules():
+        if isinstance(module, nn.Linear) and parametrize.is_parametrized(module, "weight"):
+            parametrize.remove_parametrizations(module, "weight", leave_parametrized=True)
+
+
+def set_trainable(denoiser: nn.Module, mode: str, rank: int, alpha: float) -> dict:
+    for p in denoiser.parameters():
+        p.requires_grad_(False)
+    info: dict = {"mode": mode}
+    if mode == "full":
+        for p in denoiser.parameters():
+            p.requires_grad_(True)
+    elif mode == "condenc":
+        for p in denoiser.condition_encoder.parameters():
+            p.requires_grad_(True)
+    elif mode == "lora":
+        info["lora_layers"] = add_lora(denoiser, rank, alpha)
+        info["lora_rank"], info["lora_alpha"] = rank, alpha
+        for name, p in denoiser.named_parameters():
+            p.requires_grad_(name.endswith(".A") or name.endswith(".B"))
+    else:
+        raise SystemExit(f"unknown mode {mode}")
+    trainable = [n for n, p in denoiser.named_parameters() if p.requires_grad]
+    info["n_trainable"] = int(sum(p.numel() for p in denoiser.parameters() if p.requires_grad))
+    info["n_total_base"] = int(sum(p.numel() for n, p in denoiser.named_parameters()
+                                   if not (n.endswith(".A") or n.endswith(".B"))))
+    info["trainable_tensors"] = len(trainable)
+    return info
+
+
+# ----------------------------------------------------------------------------------------------- data
+class Cells:
+    """Retained cells on the 6k panel (CSR, rows sorted by dataset row)."""
+
+    def __init__(self, path: Path, panel_gene_ids: np.ndarray) -> None:
+        z = np.load(path, allow_pickle=False)
+        self.indptr = z["indptr"].astype(np.int64)
+        self.indices = z["indices"].astype(np.int64)
+        self.data = z["data"].astype(np.float32)
+        self.row_sample = z["row_sample"].astype(np.int64)
+        self.n_genes = int(z["shape"][1])
+        if not np.array_equal(z["panel_gene_ids"].astype(str), panel_gene_ids.astype(str)):
+            raise SystemExit("cells_panel6k columns differ from the checkpoint gene panel")
+        if bool((np.diff(self.row_sample) < 0).any()):
+            raise SystemExit("cells are not sorted by dataset row")
+        n_rows = int(self.row_sample.max()) + 1
+        self.start = np.searchsorted(self.row_sample, np.arange(n_rows), side="left")
+        self.count = np.searchsorted(self.row_sample, np.arange(n_rows), side="right") - self.start
+
+    def dense(self, cells: np.ndarray) -> np.ndarray:
+        s, e = self.indptr[cells], self.indptr[cells + 1]
+        lens = e - s
+        idx = np.concatenate([np.arange(a, b) for a, b in zip(s, e)]) if len(cells) else np.zeros(0, np.int64)
+        out = np.zeros((len(cells), self.n_genes), dtype=np.float32)
+        out[np.repeat(np.arange(len(cells)), lens), self.indices[idx]] = self.data[idx]
+        return out
+
+
+def draw_batch(cells: Cells, rows: np.ndarray, batch: int, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
+    r = rows[rng.integers(0, len(rows), size=batch)]
+    c = cells.start[r] + np.floor(rng.random(batch) * cells.count[r]).astype(np.int64)
+    return r, c
+
+
+# ----------------------------------------------------------------------------------------------- main
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--checkpoint", type=Path, required=True)
+    ap.add_argument("--checkpoint-sha", required=True)
+    ap.add_argument("--dataset-dir", type=Path, required=True)
+    ap.add_argument("--condition-npz", type=Path, required=True, help="all-row condition NPZ used for training")
+    ap.add_argument("--fold", type=int, required=True)
+    ap.add_argument("--mode", choices=("full", "condenc", "lora"), required=True)
+    ap.add_argument("--lora-rank", type=int, default=16)
+    ap.add_argument("--lora-alpha", type=float, default=16.0)
+    ap.add_argument("--lr", type=float, required=True)
+    ap.add_argument("--warmup", type=int, default=200)
+    ap.add_argument("--batch-size", type=int, default=256)
+    ap.add_argument("--max-steps", type=int, default=20000)
+    ap.add_argument("--eval-every", type=int, default=250)
+    ap.add_argument("--patience", type=int, default=8)
+    ap.add_argument("--ema-decay", type=float, default=0.999)
+    ap.add_argument("--val-cells-per-row", type=int, default=256)
+    ap.add_argument("--val-repeats", type=int, default=2)
+    ap.add_argument("--seed", type=int, default=20260927)
+    ap.add_argument("--out-dir", type=Path, required=True)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--max-cuda-gib", type=float, default=8.0)
+    ap.add_argument("--min-system-gib", type=float, default=32.0)
+    ap.add_argument("--smoke", action="store_true", help="tiny run for tests (few steps, CPU allowed)")
+    ap.add_argument("--train-n", type=int, default=0, help="learning curve: number of training donors to keep")
+    ap.add_argument("--train-donors-file", default="", help="few-pair scenario: train on these donor_ids (one per "
+                    "line), no inner validation, every other usable row is test; --fold is ignored")
+    ap.add_argument("--fixed-steps", type=int, default=0, help="train exactly this many steps without inner "
+                    "validation and keep the final EMA state (for when no pairs can be spared for early stopping)")
+    ap.add_argument("--subset-seed", type=int, default=0)
+    ap.add_argument("--strata-regex", default="", help="groups matching this regex form one stratum, the rest another")
+    ap.add_argument("--support-manifest", type=Path, default=None,
+                    help="strict paired support.json: exact sample IDs, no inner validation; requires --fixed-steps 3000")
+    a = ap.parse_args(argv)
+
+    if a.support_manifest is not None:
+        if a.mode != "lora" or a.train_donors_file or a.train_n or a.fixed_steps != 3000 or a.smoke:
+            raise SystemExit("strict support requires LoRA, --fixed-steps 3000, no donor/subset override or smoke")
+        strict_tools = M8 / "plans/paper_figures_strictpairs_20261012/tools"
+        sys.path.insert(0, str(strict_tools))
+        from support_manifest import load_manifest, validate_existing_run
+        support_preflight = load_manifest(a.support_manifest, pd.read_csv(a.dataset_dir / "folds.csv",
+                                                                           dtype={"sample_id": str, "donor_id": str}))
+        if support_preflight["cohort"] != a.dataset_dir.name:
+            raise SystemExit("support cohort differs from dataset directory")
+    a.out_dir.mkdir(parents=True, exist_ok=True)
+    done = a.out_dir / "checkpoint_ft.pt"
+    if done.exists() and (a.out_dir / "RUN.json").exists():
+        if a.support_manifest is not None:
+            stored = json.loads((a.out_dir / "RUN.json").read_text())
+            validate_existing_run(support_preflight, stored, fixed_steps=a.fixed_steps,
+                                  lora_rank=a.lora_rank, source_checkpoint_sha256=a.checkpoint_sha,
+                                  condition_npz_sha256=sha256_file(a.condition_npz),
+                                  lr=a.lr, lora_alpha=a.lora_alpha, warmup=a.warmup,
+                                  batch_size=a.batch_size, ema_decay=a.ema_decay, seed=a.seed)
+            if sha256_file(a.checkpoint) != a.checkpoint_sha:
+                raise SystemExit("source checkpoint differs from requested hash")
+            if stored.get("checkpoint_sha256") != sha256_file(done):
+                raise SystemExit("existing strict checkpoint differs from RUN.json hash")
+        log(f"{done} exists; nothing to do")
+        return 0
+    if a.support_manifest is not None and (done.exists() or (a.out_dir / "RUN.json").exists()):
+        raise SystemExit("strict output is incomplete; inspect rather than overwrite")
+    avail = int(open("/proc/meminfo").read().split("MemAvailable:")[1].split()[0]) / 1048576
+    if avail < a.min_system_gib:
+        raise SystemExit(f"MemAvailable {avail:.1f} GiB < floor {a.min_system_gib}")
+    got = sha256_file(a.checkpoint)
+    if got != a.checkpoint_sha:
+        raise SystemExit(f"checkpoint sha {got[:12]} != {a.checkpoint_sha[:12]}")
+    cells_path = a.dataset_dir / "cells_panel6k.npz"
+    isolation = None
+    if a.support_manifest is not None:
+        from support_input_isolation import materialize
+        cells_path, isolation = materialize(a.support_manifest, dataset_dir=a.dataset_dir)
+    device = torch.device(a.device)
+    if device.type == "cuda" and device.index is None:
+        device = torch.device("cuda", 0)
+    if device.type == "cuda":
+        total = torch.cuda.get_device_properties(device).total_memory
+        torch.cuda.set_per_process_memory_fraction(min(1.0, a.max_cuda_gib * 2**30 / total), device)
+    torch.manual_seed(a.seed)
+    rng = np.random.default_rng(a.seed)
+
+    bundle = SS.restore_standalone(a.checkpoint, device=device, weights="ema", conditioner_source="embedded")
+    diffusion, scaler = bundle.diffusion, bundle.scaler
+    ext = SS.load_conditions(a.condition_npz, bundle, default_cells_per_bulk=1)
+    folds = pd.read_csv(a.dataset_dir / "folds.csv")
+    if not np.array_equal(folds["sample_id"].astype(str).to_numpy(), ext.sample_ids.astype(str)):
+        raise SystemExit("condition NPZ rows differ from folds.csv")
+    support = None
+    if a.support_manifest is not None:
+        from support_manifest import select_rows
+        support = support_preflight
+        train_rows, test_rows = select_rows(support, folds)
+        inner_rows = np.zeros(0, dtype=np.int64)
+        selected_visits = set(folds.loc[folds["donor_id"].astype(str).isin(support["train_donor_ids"]),
+                                        "sample_id"].astype(str))
+        if selected_visits - set(support["train_sample_ids"]) != set(support["excluded_sample_ids"]):
+            raise SystemExit("support excludes inconsistent selected-donor visits")
+        folds = folds.assign(fold=np.where(folds.index.isin(test_rows), 0,
+                                           np.where(folds.index.isin(train_rows), 1, -1)),
+                             inner_val_custom=False)
+        a.fold = 0
+        inner_col = "inner_val_custom"
+    elif a.train_donors_file:
+        # few-pair deployment scenario: train on the listed donors only, no inner validation, and treat every other
+        # usable row (fold >= 0) as test; --fold is ignored
+        want = {l.strip() for l in Path(a.train_donors_file).read_text().splitlines() if l.strip()}
+        is_train = folds["donor_id"].astype(str).isin(want) & (folds["fold"] >= 0)
+        if int(folds.loc[is_train, "donor_id"].nunique()) != len(want):
+            raise SystemExit("some listed training donors are missing or excluded")
+        folds = folds.assign(fold=np.where(folds["fold"] < 0, -1, np.where(is_train, 1, 0)))
+        folds["inner_val_custom"] = False
+        a.fold = 0
+        inner_col = "inner_val_custom"
+    else:
+        inner_col = f"inner_val_f{a.fold}"
+    test_rows = folds.index[folds["fold"] == a.fold].to_numpy()
+    inner_rows = folds.index[folds[inner_col]].to_numpy()
+    # fold -1 marks rows excluded by the pairing identity checks: never trained on, never tested
+    train_rows = folds.index[(folds["fold"] != a.fold) & (folds["fold"] >= 0)
+                             & ~folds[inner_col]].to_numpy()
+    subset_info = None
+    if a.train_n:
+        # learning curve: keep a stratified, nested subset of the training donors (inner-validation and test
+        # rows unchanged).  Each stratum is permuted once by --subset-seed, so smaller subsets are prefixes of
+        # larger ones; allocation is proportional to stratum size with at least one donor per stratum.
+        grp = folds.loc[train_rows, "group"].astype(str)
+        strata = (grp.str.contains(a.strata_regex, regex=True) if a.strata_regex
+                  else pd.Series(True, index=grp.index)).to_numpy()
+        srng = np.random.default_rng(a.subset_seed)
+        labels = sorted(set(strata.tolist()))
+        perm = {s: train_rows[strata == s][srng.permutation(int((strata == s).sum()))] for s in labels}
+        n = min(int(a.train_n), len(train_rows))
+        sizes = {s: len(perm[s]) for s in labels}
+        alloc = {s: max(1, int(np.floor(n * sizes[s] / len(train_rows)))) for s in labels}
+        while sum(alloc.values()) < n:
+            s = max(labels, key=lambda s: n * sizes[s] / len(train_rows) - alloc[s])
+            alloc[s] += 1
+        while sum(alloc.values()) > n:
+            s = max((s for s in labels if alloc[s] > 1), key=lambda s: alloc[s])
+            alloc[s] -= 1
+        train_rows = np.sort(np.concatenate([perm[s][:alloc[s]] for s in labels]))
+        subset_info = {"train_n": int(n), "subset_seed": a.subset_seed, "strata_regex": a.strata_regex,
+                       "allocation": {str(k): int(v) for k, v in alloc.items()}}
+    if set(test_rows) & (set(inner_rows) | set(train_rows)):
+        raise SystemExit("test rows overlap training rows")
+    if set(folds.loc[test_rows, "donor_id"]) & set(folds.loc[np.r_[train_rows, inner_rows], "donor_id"]):
+        raise SystemExit("a test donor also appears in training")
+
+    cells = Cells(cells_path, bundle.gene_ids)
+    with np.load(cells_path, allow_pickle=False) as z:
+        panel_measured = z["panel_measured"].astype(bool)
+    if not np.array_equal(panel_measured, ext.output_availability_mask.astype(bool)):
+        raise SystemExit("cells' measured panel differs from the condition NPZ output_availability_mask")
+
+    base = torch.from_numpy(ext.base_conditions.astype(np.float32)).to(device)
+    bulk_frac = torch.from_numpy(ext.bulk_measurement_fraction.astype(np.float32)).to(device)
+    avail_rows = torch.from_numpy(ext.output_availability_mask.astype(bool)).to(device)
+    cond_rows = condition_with_measurement_context(base, bulk_frac, avail_rows)   # [rows, condition_dim]
+
+    denoiser = diffusion.denoiser
+    info = set_trainable(denoiser, a.mode, a.lora_rank, a.lora_alpha)
+    params = [p for p in denoiser.parameters() if p.requires_grad]
+    named = [(n, p) for n, p in denoiser.named_parameters() if p.requires_grad]
+    opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.0)
+    ema = {n: p.detach().clone() for n, p in named}
+    log(f"mode={a.mode} trainable={info['n_trainable']:,} rows train/inner/test="
+        f"{len(train_rows)}/{len(inner_rows)}/{len(test_rows)} cells(train)={int(cells.count[train_rows].sum()):,}")
+
+    # fixed inner-validation draws
+    vrng = np.random.default_rng(a.seed + 1)
+    val_cells, val_rows = [], []
+    for r in inner_rows:
+        n = int(cells.count[r])
+        take = min(a.val_cells_per_row, n)
+        pick = cells.start[r] + np.sort(vrng.choice(n, size=take, replace=False))
+        val_cells.append(pick)
+        val_rows.append(np.full(take, r))
+    val_cells = np.concatenate(val_cells) if val_cells else np.zeros(0, np.int64)
+    val_rows = np.concatenate(val_rows) if val_rows else np.zeros(0, np.int64)
+
+    def to_batch(r: np.ndarray, c: np.ndarray):
+        x_log = torch.from_numpy(np.log1p(cells.dense(c))).to(device)
+        rr = torch.from_numpy(r).to(device)
+        availability = avail_rows[rr]
+        return scaler.to_unit_tensor(x_log), cond_rows[rr], availability, x_log > 0
+
+    def swap_in_ema() -> dict:
+        backup = {n: p.detach().clone() for n, p in named}
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(ema[n])
+        return backup
+
+    def restore(backup: dict) -> None:
+        with torch.no_grad():
+            for n, p in named:
+                p.copy_(backup[n])
+
+    @torch.no_grad()
+    def val_loss() -> float:
+        if len(val_cells) == 0:
+            return float("nan")
+        diffusion.eval()
+        tot, n = 0.0, 0
+        for rep in range(a.val_repeats):
+            for i in range(0, len(val_cells), a.batch_size):
+                g = torch.Generator(device=device).manual_seed(a.seed + 1_000_003 * rep + i)
+                v, c, m, act = to_batch(val_rows[i:i + a.batch_size], val_cells[i:i + a.batch_size])
+                with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+                    res = diffusion.training_loss(v, c, availability_mask=m, active_target=act, generator=g)
+                tot += float(res.loss) * v.shape[0]
+                n += v.shape[0]
+        diffusion.train()
+        return tot / max(n, 1)
+
+    history = []
+    best = {"loss": val_loss(), "step": 0}
+    best_state = {n: t.detach().cpu().clone() for n, t in ema.items()}
+    history.append({"step": 0, "inner_val_loss": best["loss"], "train_loss": None})
+    log(f"step 0 inner-val loss {best['loss']:.5f} (pretrained)")
+    gen = torch.Generator(device=device).manual_seed(a.seed + 7)
+    diffusion.train()
+    t0 = time.time()
+    run_loss, run_n, bad = 0.0, 0, 0
+    max_steps = 20 if a.smoke else (a.fixed_steps or a.max_steps)
+    eval_every = 5 if a.smoke else a.eval_every
+    step = 0
+    for step in range(1, max_steps + 1):
+        for gparam in opt.param_groups:
+            gparam["lr"] = a.lr * min(1.0, step / max(1, a.warmup))
+        r, c = draw_batch(cells, train_rows, a.batch_size, rng)
+        v, cond, m, act = to_batch(r, c)
+        opt.zero_grad(set_to_none=True)
+        with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=device.type == "cuda"):
+            res = diffusion.training_loss(v, cond, availability_mask=m, active_target=act, generator=gen)
+        if not bool(torch.isfinite(res.loss)):
+            raise FloatingPointError(f"non-finite loss at step {step}")
+        res.loss.backward()
+        norm = nn.utils.clip_grad_norm_(params, 5.0)
+        if not bool(torch.isfinite(norm)):
+            raise FloatingPointError(f"non-finite grad norm at step {step}")
+        opt.step()
+        with torch.no_grad():
+            for n_, p in named:
+                ema[n_].lerp_(p.detach(), 1.0 - a.ema_decay)
+        run_loss += float(res.loss.detach())
+        run_n += 1
+        if a.fixed_steps and step == max_steps:
+            best = {"loss": float("nan"), "step": step}
+            best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+        if step % eval_every == 0 and not a.fixed_steps:
+            backup = swap_in_ema()
+            vl = val_loss()
+            restore(backup)
+            rec = {"step": step, "inner_val_loss": vl, "train_loss": run_loss / run_n,
+                   "sec": round(time.time() - t0, 1)}
+            history.append(rec)
+            run_loss, run_n = 0.0, 0
+            if vl < best["loss"] - 1e-6:
+                best = {"loss": vl, "step": step}
+                best_state = {n_: t.detach().cpu().clone() for n_, t in ema.items()}
+                bad = 0
+            else:
+                bad += 1
+            log(f"step {step} train {rec['train_loss']:.5f} inner-val {vl:.5f} best {best['loss']:.5f}@{best['step']} "
+                f"({rec['sec']:.0f}s)")
+            (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+            if bad >= a.patience:
+                log(f"early stop: no improvement in {a.patience} evaluations")
+                break
+
+    # load the selected EMA state, merge LoRA, save a self-contained checkpoint
+    with torch.no_grad():
+        for n_, p in named:
+            p.copy_(best_state[n_].to(device))
+    if a.mode == "lora":
+        merge_lora(denoiser)
+    state = {k: v.detach().cpu().clone() for k, v in denoiser.state_dict().items()}
+    payload_in = SS._load_checkpoint_cpu(a.checkpoint)
+    ref_state = payload_in["ema_state"]["model_state"]
+    if set(ref_state.keys()) != set(state.keys()):
+        raise SystemExit("fine-tuned state keys differ from the checkpoint's")
+    changed = {k: float((state[k].float() - ref_state[k].float()).abs().max()) for k in state}
+    out = {k: payload_in[k] for k in KEEP_KEYS if k in payload_in}
+    out["model_state"] = state
+    out["ema_state"] = {"model_state": state}
+    ft_meta = {
+        "schema": SCHEMA, "source_checkpoint": str(a.checkpoint), "source_checkpoint_sha256": got,
+        "dataset_dir": str(a.dataset_dir), "condition_npz": str(a.condition_npz),
+        "condition_npz_sha256": ext.input_sha256, "fold": a.fold, "mode": a.mode, "trainable": info,
+        "lr": a.lr, "warmup": a.warmup, "batch_size": a.batch_size, "ema_decay": a.ema_decay,
+        "max_steps": max_steps, "steps_run": step, "eval_every": eval_every, "patience": a.patience,
+        "train_subset": subset_info, "train_donors_file": a.train_donors_file or None,
+        "support_manifest": str(a.support_manifest) if support else None,
+        "support_sha256": support["sha256"] if support else None,
+        "train_donor_ids": support["train_donor_ids"] if support else None,
+        "excluded_selected_donor_visits": support["excluded_sample_ids"] if support else None,
+        "fixed_steps": a.fixed_steps or None,
+        "selected_step": best["step"], "selected_inner_val_loss": best["loss"],
+        "pretrained_inner_val_loss": history[0]["inner_val_loss"],
+        "train_rows": [str(x) for x in folds.loc[train_rows, "sample_id"]],
+        "inner_val_rows": [str(x) for x in folds.loc[inner_rows, "sample_id"]],
+        "test_rows_never_loaded_for_training": [str(x) for x in folds.loc[test_rows, "sample_id"]],
+        "max_abs_weight_change": max(changed.values()),
+        "n_tensors_changed": int(sum(v > 0 for v in changed.values())),
+        "seed": a.seed, "wall_seconds": round(time.time() - t0, 1),
+        "written_utc": datetime.now(timezone.utc).isoformat(),
+    }
+    if isolation is not None:
+        ft_meta["support_expression_isolation"] = isolation
+    out["finetune"] = ft_meta
+    tmp = a.out_dir / "checkpoint_ft.pt.tmp"
+    torch.save(out, tmp)
+    os.replace(tmp, done)
+    ft_meta["checkpoint_sha256"] = sha256_file(done)
+    # reload through the sampler's own restore path and compare one forward pass
+    check = SS.restore_standalone(done, device=torch.device("cpu"), weights="ema", conditioner_source="embedded")
+    ref = SS.restore_standalone(done, device=torch.device("cpu"), weights="raw", conditioner_source="embedded")
+    xs = torch.randn(4, check.diffusion.state_dim, generator=torch.Generator().manual_seed(0))
+    tt = torch.full((4,), 0.5)
+    cc = cond_rows[torch.from_numpy(train_rows[:1]).to(device)].repeat(4, 1).float().cpu()
+    denoiser_cpu = denoiser.to("cpu").float().eval()
+    with torch.no_grad():
+        o1 = check.diffusion.denoiser(xs, tt, cc).value_prediction
+        o2 = denoiser_cpu(xs, tt, cc).value_prediction
+        o3 = ref.diffusion.denoiser(xs, tt, cc).value_prediction
+    ft_meta["reload_forward_max_abs_diff"] = float(max((o1 - o2).abs().max(), (o1 - o3).abs().max()))
+    if ft_meta["reload_forward_max_abs_diff"] > 1e-4:
+        raise SystemExit(f"reloaded checkpoint differs: {ft_meta['reload_forward_max_abs_diff']}")
+    (a.out_dir / "history.json").write_text(json.dumps(history, indent=1))
+    (a.out_dir / "RUN.json").write_text(json.dumps(ft_meta, indent=1))
+    log(f"saved {done} (selected step {best['step']}, inner-val {best['loss']:.5f} vs pretrained "
+        f"{history[0]['inner_val_loss']:.5f}); sha {ft_meta['checkpoint_sha256'][:12]}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261013T124345Z-trunk4x-lora-sepsis-launch/diffusion/dataset/server_1/model8/plans/trunk4x_lora_sepsis_20261013/tools/gpu_campaign.py

@@ -0,0 +1,56 @@
+"""Sequential GPU campaign; must be invoked via remote ml-run. No retries."""
+from pathlib import Path
+from datetime import datetime,timezone
+import json,os,sys,subprocess,hashlib,socket,traceback
+ROOT=Path(__file__).resolve().parents[1];M=ROOT.parents[1]
+def sha(p):
+ with Path(p).open('rb') as f:return hashlib.file_digest(f,'sha256').hexdigest()
+def state(phase,**kw):
+ j=dict(phase=phase,host=socket.gethostname(),at=datetime.now(timezone.utc).isoformat(),**kw)
+ tmp=ROOT/'GPU_STATUS.tmp';tmp.write_text(json.dumps(j,indent=2)+'\n');tmp.replace(ROOT/'GPU_STATUS.json');print(json.dumps(j),flush=True)
+def run(argv,path):
+ if path.exists():raise RuntimeError('Existing operation log; inspect instead of retry: '+str(path))
+ subprocess.run(['systemctl','--user','is-active','--quiet','ml-memory-guard.service'],check=True)
+ subprocess.run(['/home/sj_server_2/.local/libexec/ml-memory-guard','--check'],check=True)
+ pids=subprocess.check_output(['nvidia-smi','--query-compute-apps=pid','--format=csv,noheader'],text=True).strip()
+ if pids:raise RuntimeError('Unexpected active CUDA PID while holding shared lock: '+pids)
+ with path.open('x') as f:subprocess.run(argv,stdout=f,stderr=subprocess.STDOUT,check=True)
+def main():
+ assert 'ml.slice' in Path('/proc/self/cgroup').read_text()
+ protocol=json.loads((ROOT/'PROTOCOL.json').read_text());state('preflight')
+ for rel,h in protocol['files'].items():assert sha(ROOT/rel)==h,rel
+ for rel,h in protocol['code'].items():assert sha(ROOT/rel)==h,rel
+ for arm,cfg in protocol['arms'].items():
+  cp=M/'runs'/cfg['run']/'checkpoint_epoch_016.pt';assert sha(cp)==cfg['sha256']
+ for draw in range(5):
+  data=ROOT/f'data/draw{draw}/ye2026_sepsis';sup=json.loads((data/'support.json').read_text())
+  for arm,cfg in protocol['arms'].items():
+   if (ROOT/f'completed/{arm}_draw{draw}.json').exists():raise RuntimeError('Already completed; no implicit replay')
+   out=ROOT/f'runs/{arm}/draw{draw}';out.mkdir(parents=True,exist_ok=True)
+   if (out/'checkpoint_ft.pt').exists():raise RuntimeError('Checkpoint already present; inspect before retry')
+   state('training',arm=arm,draw=draw,log=str(out/'train.log'))
+   base=M/'runs'/cfg['run']/'checkpoint_epoch_016.pt'
+   cmd=[sys.executable,'-u',str(ROOT/'tools/ft_sdd_frozen.py'),'--checkpoint',str(base),'--checkpoint-sha',cfg['sha256'],
+    '--dataset-dir',str(data),'--condition-npz',str(ROOT/'data/conditions_raw_fixed.npz'),'--fold','0','--mode','lora',
+    '--lora-rank','16','--lora-alpha','16','--lr','0.0005','--warmup','200','--batch-size','256','--ema-decay','0.999',
+    '--seed','20260927','--train-donors-file',str(data/'train_donors.txt'),'--fixed-steps','3000','--out-dir',str(out),
+    '--max-cuda-gib','24','--min-system-gib','32']
+   run(cmd,out/'train.log');r=json.loads((out/'RUN.json').read_text())
+   assert set(r['train_rows'])==set(sup['train_sample_ids']) and set(r['test_rows_never_loaded_for_training'])==set(sup['test_sample_ids'])
+   assert not r['inner_val_rows'] and r['steps_run']==3000 and r['source_checkpoint_sha256']==cfg['sha256']
+   cp=out/'checkpoint_ft.pt';assert sha(cp)==r['checkpoint_sha256']
+   gen=ROOT/f'generated/{arm}/draw{draw}/cells.npz';gen.parent.mkdir(parents=True,exist_ok=True)
+   # Conservative disk floor: retain existing outputs, stop rather than consume last headroom.
+   import shutil
+   if shutil.disk_usage(ROOT).free<40*2**30:raise RuntimeError('Remote free disk <40GiB; preserve and inspect')
+   state('generating',arm=arm,draw=draw,output=str(gen))
+   run([sys.executable,'-u',str(ROOT/'tools/sample_one_frozen.py'),'--checkpoint',str(cp),'--checkpoint-sha',r['checkpoint_sha256'],
+        '--condition',str(data/'test_raw.npz'),'--output',str(gen),'--seed','20260928'],gen.parent/'wrapper.log')
+   receipt=json.loads(gen.with_suffix('.log').read_text());assert receipt['output_sha256']==sha(gen)
+   done={'arm':arm,'draw':draw,'host':socket.gethostname(),'checkpoint':str(cp),'checkpoint_sha256':r['checkpoint_sha256'],
+         'output':str(gen),'output_sha256':receipt['output_sha256'],'support_sha256':sup['sha256'],'at':datetime.now(timezone.utc).isoformat()}
+   (ROOT/'completed').mkdir(exist_ok=True);(ROOT/f'completed/{arm}_draw{draw}.json').write_text(json.dumps(done,indent=2)+'\n')
+ state('gpu_complete',arms=2,draws=5)
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:state('failed',error=str(e));raise

paper-releases/pbisc-diffusion/updates/20261013T124345Z-trunk4x-lora-sepsis-launch/diffusion/dataset/server_1/model8/plans/trunk4x_lora_sepsis_20261013/tools/prepare.py

@@ -0,0 +1,57 @@
+"""CPU-only exact-support panel projection, preserving cell-row RNG semantics."""
+from pathlib import Path
+import os,sys,json,hashlib,shutil
+import numpy as np
+import pandas as pd
+from scipy import sparse
+assert os.environ.get('CUDA_VISIBLE_DEVICES')==''
+ROOT=Path(__file__).resolve().parents[1];M=ROOT.parents[1];F=M/'plans/paired_finetune_intradataset_20260927';S=M/'plans/paper_figures_strictpairs_20261012'
+sys.path.insert(0,str(S/'tools'))
+from support_input_isolation import read_ranges
+
+def sha(p):
+ with Path(p).open('rb') as f:return hashlib.file_digest(f,'sha256').hexdigest()
+def write(p,j):p.parent.mkdir(parents=True,exist_ok=True);p.write_text(json.dumps(j,indent=2)+'\n')
+def main():
+ ds=F/'data/ye2026_sepsis';source=ds/'cells_full.npz';source_hash=sha(source)
+ old=json.loads((M/'runs/s0_6k_allK_topup16_seed20260627_arch4x_ctx512_v1/data_audit.json').read_text())
+ one=json.loads((M/'runs/s0_6k_allK_topup16_seed20260627_bundle_v2/data_audit.json').read_text())
+ assert old['gene_ids']==one['gene_ids']
+ genes=np.asarray(old['gene_ids'],dtype=str)
+ with np.load(ds/'features.npz',allow_pickle=False) as z:
+  canon=z['gene_ids'].astype(str);pos=np.array([list(canon).index(g) for g in genes]);measured=z['sc_valid'][:,pos]
+ with np.load(source,allow_pickle=False) as z:ip=z['indptr'];rs=z['row_sample'];shape=z['shape']
+ folds=pd.read_csv(ds/'folds.csv');gene_map=np.full(len(canon),-1,dtype=np.int32);gene_map[pos]=np.arange(6000)
+ config={'schema':'pbisc.trunk-lora.representative.v1','cohort':'ye2026_sepsis','primary_comparison':'legacy_panel_1x_vs_legacy_panel_trunk4x','draws':[],'arms':{'trunk4x':{'run':'s0_6k_allK_topup16_seed20260627_arch4x_ctx512_v1','sha256':'f780813e784d0467ad278e0aea07b629349089ae4cd09aab718f1ce70bd179fd'},'panel_matched_1x':{'run':'s0_6k_allK_topup16_seed20260627_bundle_v2','sha256':'6c1aa7b55a5784a3b97c15d75b053e59d69549d6f84c38edf44ff4f6858ed99c'}},'train':{'rank':16,'alpha':16,'steps':3000,'lr':0.0005,'warmup':200,'batch_size':256,'ema':0.999,'seed':20260927},'sampling':{'steps':50,'seed':20260928,'cells_per_sample':1500,'support_readout':'bernoulli'},'source_full_cells_sha256':source_hash,'files':{}}
+ for draw in range(5):
+  support_path=S/f'protocol/splits/ye2026_sepsis/disease/draw{draw}/support.json';support=json.loads(support_path.read_text())
+  legacy=json.loads((F/f'runs/ye2026_sepsis/fewshot_n5/draw{draw}/lora/RUN.json').read_text())
+  assert set(support['train_sample_ids'])==set(legacy['train_rows']) and not legacy['inner_val_rows']
+  assert set(support['test_sample_ids'])==set(legacy['test_rows_never_loaded_for_training'])
+  rows=folds.index[folds.sample_id.isin(support['train_sample_ids'])].to_numpy();use=np.isin(rs,rows);selected=np.flatnonzero(use)
+  starts=selected[np.r_[True,np.diff(selected)!=1]];ends=selected[np.r_[np.diff(selected)!=1,True]]+1
+  ranges=[(int(ip[a]),int(ip[b])) for a,b in zip(starts,ends)]
+  data=read_ranges(source,'data',ranges,expected_length=int(ip[-1]));indices=read_ranges(source,'indices',ranges,expected_length=int(ip[-1]))
+  sip=np.r_[0,np.cumsum(np.where(use,np.diff(ip),0),dtype=np.int64)]
+  x=sparse.csr_matrix((data,indices,sip),shape=tuple(shape));xp=x[:,pos].tocsr();del x,data,indices
+  assert xp[~use].nnz==0 and xp.shape[0]==len(rs)
+  out=ROOT/f'data/draw{draw}/ye2026_sepsis';out.mkdir(parents=True,exist_ok=True)
+  np.savez_compressed(out/'cells_panel6k.npz',data=xp.data,indices=xp.indices,indptr=xp.indptr,row_sample=rs,shape=np.array(xp.shape),panel_gene_ids=genes,panel_measured=measured)
+  shutil.copy2(ds/'folds.csv',out/'folds.csv');shutil.copy2(support_path,out/'support.json')
+  (out/'train_donors.txt').write_text('\n'.join(support['train_donor_ids'])+'\n')
+  shutil.copy2(S/f'data/ye2026_sepsis/disease/draw{draw}/test_raw.npz',out/'test_raw.npz')
+  j={'draw':draw,'train':support['train_sample_ids'],'test':support['test_sample_ids'],'support_sha256':support['sha256'],'support_cells':int(use.sum()),'non_support_expression_entries':0,'isolated_panel_sha256':sha(out/'cells_panel6k.npz'),'cell_rng_row_order_preserved':True,'legacy_run':str(F/f'runs/ye2026_sepsis/fewshot_n5/draw{draw}/lora/RUN.json')}
+  write(out/'PREPARATION.json',j);config['draws'].append(j);print('Prepared',draw,flush=True)
+ shutil.copy2(ds/'conditions_raw_fixed.npz',ROOT/'data/conditions_raw_fixed.npz')
+ shutil.copy2(F/'tools/ft_sdd.py',ROOT/'tools/ft_sdd_frozen.py')
+ shutil.copy2(S/'tools/sample_one.py',ROOT/'tools/sample_one_frozen.py')
+ shutil.copy2(S/'tools/runtime.py',ROOT/'tools/runtime.py')
+ current=json.loads((M/'runs/f01_6k_1x_seed20260627/data_audit.json').read_text())['gene_ids'];common=[g for g in current if g in set(genes)]
+ assert len(common)==4258
+ (ROOT/'data/common_genes.txt').write_text('\n'.join(common)+'\n')
+ for p in (ROOT/'data').rglob('*'):
+  if p.is_file():config['files'][str(p.relative_to(ROOT))]=sha(p)
+ config['code']={str(p.relative_to(ROOT)):sha(p) for p in (ROOT/'tools').glob('*.py')}
+ write(ROOT/'PROTOCOL.json',config)
+ print('PROTOCOL complete; no held-out expression materialized for training',flush=True)
+if __name__=='__main__':main()

paper-releases/pbisc-diffusion/updates/20261013T124345Z-trunk4x-lora-sepsis-launch/diffusion/dataset/server_1/model8/plans/trunk4x_lora_sepsis_20261013/tools/runtime.py

@@ -0,0 +1,323 @@
+"""Bounded, receipt-bound execution; never retries failed scientific operations."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import socket
+import subprocess
+import time
+
+
+class ReceiptError(RuntimeError):
+    """An output cannot be attributed safely to the requested operation."""
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def stamp() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def atomic_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + f".tmp-{os.getpid()}")
+    tmp.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n")
+    tmp.replace(path)
+
+
+def stat_record(path: Path) -> dict:
+    st = path.stat()
+    return {"path": str(path.resolve()), "bytes": st.st_size, "mtime_ns": st.st_mtime_ns}
+
+
+class Runtime:
+    def __init__(self, root: Path):
+        self.root = root.resolve()
+        self.started_at = stamp()
+        self._execution_map, self._map_path, self._map_sha256 = self._load_execution_map()
+        (self.root / "receipts").mkdir(parents=True, exist_ok=True)
+        (self.root / "logs").mkdir(parents=True, exist_ok=True)
+        self._guard_restarted = False
+
+    @staticmethod
+    def _absolute_path(value: str, *, executable: bool = False) -> Path:
+        if (not isinstance(value, str) or not value or
+                any(ord(char) < 32 for char in value) or not Path(value).is_absolute()):
+            raise ValueError("execution paths must be absolute strings without control characters")
+        path = Path(value)
+        if executable and (not path.is_file() or not os.access(path, os.X_OK)):
+            raise ValueError(f"execution path is not an executable file: {value}")
+        return path
+
+    def _load_execution_map(self) -> tuple[dict, str | None, str | None]:
+        config_path = os.environ.get("PBISC_STRICT_EXECUTION_MAP")
+        if not config_path:
+            return {}, None, None
+        path = self._absolute_path(config_path)
+        try:
+            raw = path.read_bytes()
+            config = json.loads(raw)
+        except (OSError, ValueError) as exc:
+            raise ValueError(f"cannot read execution map: {path}") from exc
+        required = {"host", "executables", "ml_run", "guard_check", "path"}
+        if not isinstance(config, dict) or set(config) != required:
+            raise ValueError(f"execution map must contain exactly {sorted(required)}")
+        if not isinstance(config["host"], str) or not re.fullmatch(r"[A-Za-z0-9_.-]+", config["host"]):
+            raise ValueError("execution map host must be a nonempty host label")
+        if not isinstance(config["executables"], dict):
+            raise ValueError("execution map executables must be a mapping")
+        for canonical, actual in config["executables"].items():
+            self._absolute_path(canonical)
+            self._absolute_path(actual, executable=True)
+        for field in ("ml_run", "guard_check"):
+            self._absolute_path(config[field], executable=True)
+        if not isinstance(config["path"], str):
+            raise ValueError("execution map path must be an absolute-directory PATH string")
+        for directory in config["path"].split(os.pathsep):
+            self._absolute_path(directory)
+        return config, str(path.resolve()), hashlib.sha256(raw).hexdigest()
+
+    def execution_argv(self, argv: list[str]) -> list[str]:
+        if not argv:
+            raise ValueError("execution command must not be empty")
+        actual = [str(arg) for arg in argv]
+        actual[0] = self._execution_map.get("executables", {}).get(actual[0], actual[0])
+        return actual
+
+    def execution_metadata(self, argv: list[str] | None = None,
+                           command: list[str] | None = None) -> dict:
+        return {"host": socket.gethostname(), "map_host": self._execution_map.get("host"),
+                "map_path": self._map_path, "map_sha256": self._map_sha256,
+                "argv": self.execution_argv(argv) if argv is not None else None,
+                "command": command}
+
+    def _execution_environment(self) -> dict:
+        env = os.environ.copy()
+        if self._execution_map:
+            env["PATH"] = self._execution_map["path"]
+        return env
+
+    def receipt_path(self, name: str) -> Path:
+        if not re.fullmatch(r"[A-Za-z0-9_.-]+", name):
+            raise ValueError(f"invalid operation name {name!r}")
+        return self.root / "receipts" / f"{name}.json"
+
+    def event(self, name: str, state: str, **details) -> None:
+        record = {"at": stamp(), "operation": name, "state": state, **details}
+        with (self.root / "events.jsonl").open("a") as stream:
+            stream.write(json.dumps(record, allow_nan=False) + "\n")
+        print(f"{record['at']} {name}: {state}", flush=True)
+
+    def signature(self, argv: list[str], inputs: list[Path]) -> str:
+        value = {"argv": [str(x) for x in argv], "inputs": [
+            {"path": str(p.resolve()), "sha256": sha256(p)} for p in inputs]}
+        return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+    def write_receipt(self, name: str, value: dict) -> None:
+        atomic_json(self.receipt_path(name), value)
+
+    def can_skip(self, name: str, signature: str, outputs: list[Path],
+                 previous_outputs: dict | None = None) -> bool:
+        receipt = self.receipt_path(name)
+        if not receipt.exists():
+            for p in outputs:
+                if not p.exists():
+                    continue
+                prior = (previous_outputs or {}).get(str(p))
+                if (not prior or p.suffix in (".npz", ".pt", ".pth", ".safetensors") or
+                        not p.resolve().is_relative_to(self.root)):
+                    raise ReceiptError(f"{name}: unreceipted output exists; preserve and inspect")
+                backup = Path(prior["backup"])
+                if (not backup.is_file() or backup.resolve() == p.resolve() or
+                        sha256(p) != prior["sha256"] or sha256(backup) != prior["sha256"]):
+                    raise ReceiptError(f"{name}: preview replacement is not bound to a preserved copy")
+            return False
+        record = json.loads(receipt.read_text())
+        if record.get("state") != "completed":
+            raise ReceiptError(f"{name}: previous {record.get('state')}; inspect before explicit recovery")
+        if record.get("signature") != signature:
+            self._verify_source_reuse(name, record.get("signature"), signature, receipt)
+        old = record.get("outputs", [])
+        if len(old) != len(outputs):
+            raise ReceiptError(f"{name}: output contract changed")
+        for p, expected in zip(outputs, old):
+            if not p.is_file() or stat_record(p) != {k: expected[k] for k in ("path", "bytes", "mtime_ns")}:
+                raise ReceiptError(f"{name}: output missing or modified: {p}")
+            if sha256(p) != expected.get("sha256"):
+                raise ReceiptError(f"{name}: output hash changed: {p}")
+        return True
+
+    def _verify_source_reuse(self, name: str, old_signature: str, new_signature: str,
+                             receipt: Path) -> None:
+        """Allow only a reviewed, hash-bound transition; never rewrite its historical receipt."""
+        manifest = self.root / "recoveries" / "SOURCE_REUSE.json"
+        if not manifest.is_file():
+            raise ReceiptError(f"{name}: scientific inputs or command changed; use a new version")
+        try:
+            recovery = json.loads(manifest.read_bytes())
+            if (not isinstance(recovery, dict) or
+                    recovery.get("schema") != "pbisc.strictpairs.source-reuse.v1" or
+                    not isinstance(recovery.get("transitions"), list)):
+                raise ValueError("invalid source reuse manifest schema")
+            if not all(isinstance(item, dict) for item in recovery["transitions"]):
+                raise ValueError("invalid source reuse transition")
+            matches = [item for item in recovery["transitions"]
+                       if (item.get("operation"), item.get("old_signature"), item.get("new_signature"))
+                       == (name, old_signature, new_signature)]
+            if len(matches) != 1:
+                raise ValueError("no unique approval for this exact operation and signature transition")
+            transition = matches[0]
+            if not all(isinstance(value, str) and re.fullmatch(r"[0-9a-f]{64}", value)
+                       for value in (old_signature, new_signature)):
+                raise ValueError("source reuse signatures must be SHA-256 values")
+
+            def verify_file(binding: dict) -> Path:
+                if not isinstance(binding, dict):
+                    raise ValueError("invalid source reuse file binding")
+                path = self._absolute_path(binding["path"])
+                digest = binding["sha256"]
+                if (not isinstance(digest, str) or not re.fullmatch(r"[0-9a-f]{64}", digest) or
+                        not path.is_file() or sha256(path) != digest):
+                    raise ValueError(f"source reuse bound file changed or missing: {path}")
+                return path
+
+            original = verify_file(transition["original_receipt"])
+            if sha256(receipt) != sha256(original):
+                raise ValueError("current historical receipt differs from preserved original")
+            evidence = transition["evidence"]
+            if not isinstance(evidence, list) or not evidence:
+                raise ValueError("source reuse requires named evidence files")
+            names = set()
+            for binding in evidence:
+                if (not isinstance(binding, dict) or not isinstance(binding.get("name"), str) or
+                        not binding["name"].strip() or binding["name"] in names):
+                    raise ValueError("source reuse evidence must have unique nonempty names")
+                names.add(binding["name"])
+                verify_file(binding)
+        except (OSError, ValueError, KeyError, TypeError) as exc:
+            raise ReceiptError(f"{name}: source reuse attestation failed: {exc}") from exc
+
+    def record_completed(self, name: str, signature: str, outputs: list[Path], seconds: float,
+                         *, execution: dict | None = None, argv: list[str] | None = None,
+                         previous_outputs: dict | None = None) -> None:
+        records = []
+        for path in outputs:
+            if not path.is_file() or path.stat().st_size == 0:
+                raise ReceiptError(f"{name}: missing or empty required output {path}")
+            records.append({**stat_record(path), "sha256": sha256(path)})
+        self.write_receipt(name, {"state": "completed", "signature": signature,
+                                  "outputs": records, "seconds": seconds, "at": stamp(),
+                                  "execution": execution if execution is not None else self.execution_metadata(),
+                                  "argv": argv, "previous_outputs": previous_outputs})
+
+    def wrapped_command(self, name: str, argv: list[str], resource: str,
+                        memory_gib: int, threads: int) -> list[str]:
+        if resource not in ("cpu", "gpu"):
+            raise ValueError("resource must explicitly be cpu or gpu")
+        if not 1 <= threads <= 8 or not 1 <= memory_gib <= 64:
+            raise ValueError("unsafe CPU/memory budget")
+        actual_argv = self.execution_argv(argv)
+        path = self._execution_map.get("path", "/home/sj_server_1/.local/bin:/home/sj_server_1/miniforge3/bin:/usr/local/bin:/usr/bin:/bin")
+        env = [f"PATH={path}",
+               "PYTHONDONTWRITEBYTECODE=1", "PYTHONUNBUFFERED=1", f"OMP_NUM_THREADS={threads}",
+               f"OPENBLAS_NUM_THREADS={threads}", f"MKL_NUM_THREADS={threads}",
+               f"NUMBA_NUM_THREADS={threads}"]
+        if resource == "gpu":
+            return [self._execution_map.get("ml_run", "/home/sj_server_1/.local/bin/ml-run"),
+                    "/usr/bin/env", "CUDA_VISIBLE_DEVICES=0",
+                    "PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True", *env, *actual_argv]
+        unit = f"pbisc-strict-{name[:100]}-{os.getpid()}-{time.time_ns()}"
+        return ["systemd-run", "--user", "--wait", "--collect", "--pipe", "--quiet",
+                f"--unit={unit}", "--slice=app.slice", f"--working-directory={self.root}",
+                "--expand-environment=no", "-p", f"MemoryMax={memory_gib}G", "-p", "MemorySwapMax=0",
+                "-p", "OOMPolicy=kill", "-p", "OOMScoreAdjust=500", "-p", f"CPUQuota={threads * 100}%",
+                "/usr/bin/env", "CUDA_VISIBLE_DEVICES=", *env, *actual_argv]
+
+    def preflight(self, resource: str, memory_gib: int) -> None:
+        # Every substantial CPU operation and every CUDA operation checks all three controls.
+        env = self._execution_environment()
+        active = subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"],
+                                capture_output=True, text=True, env=env)
+        if active.returncode:
+            if not self._guard_restarted:
+                self._guard_restarted = True
+                subprocess.run(["systemctl", "--user", "restart", "ml-memory-guard.service"], check=True, env=env)
+            subprocess.run(["systemctl", "--user", "is-active", "ml-memory-guard.service"], check=True, env=env)
+        subprocess.run([self._execution_map.get("guard_check", "/home/sj_server_1/.local/libexec/ml-memory-guard"),
+                        "--check"], check=True, env=env)
+        compute = subprocess.run(["nvidia-smi", "--query-compute-apps=pid,process_name,used_memory",
+                                  "--format=csv,noheader"], capture_output=True, text=True, check=True, env=env)
+        guard_log = subprocess.run(["journalctl", "-t", "ml-memory-guard", "--since", self.started_at,
+                                    "--no-pager"], capture_output=True, text=True, check=True, env=env)
+        if "stopping ml.slice" in guard_log.stdout:
+            raise RuntimeError("memory guard stopped ml.slice; inspect evidence before any restart")
+        available = next(int(line.split()[1]) / 1048576 for line in Path("/proc/meminfo").read_text().splitlines()
+                         if line.startswith("MemAvailable:"))
+        floor = max(32, memory_gib + 24) if resource == "cpu" else 48
+        if shutil.disk_usage(self.root).free < 64 * 2**30:
+            raise BlockingIOError("less than 64 GiB free disk; preserve originals and wait for storage")
+        if available < floor:
+            raise BlockingIOError(f"MemAvailable {available:.1f} GiB below {floor} GiB launch floor")
+        if resource == "gpu":
+            if compute.stdout.strip():
+                raise BlockingIOError("another CUDA process is active")
+            lock = subprocess.run(["flock", "--nonblock", "/run/user/1000/ml-gpu0.lock", "true"], env=env)
+            if lock.returncode:
+                raise BlockingIOError("shared GPU lock is held")
+
+    def execute(self, name: str, argv: list[str], *, resource: str = "cpu", memory_gib: int = 16,
+                threads: int = 4, inputs: list[Path] | None = None,
+                outputs: list[Path] | None = None, wait_seconds: int = 86400,
+                previous_outputs: dict | None = None) -> bool:
+        inputs, outputs = inputs or [], outputs or []
+        signature = self.signature(argv, inputs)
+        if self.can_skip(name, signature, outputs, previous_outputs=previous_outputs):
+            self.event(name, "verified_skip")
+            return False
+        wait_start, announced = time.monotonic(), False
+        while True:
+            try:
+                self.preflight(resource, memory_gib)
+                break
+            except BlockingIOError as exc:
+                if not announced:
+                    self.event(name, "waiting_resources", reason=str(exc))
+                    announced = True
+                if time.monotonic() - wait_start > wait_seconds:
+                    raise TimeoutError(str(exc)) from exc
+                time.sleep(15)
+        command = self.wrapped_command(name, argv, resource, memory_gib, threads)
+        execution = self.execution_metadata(argv, command)
+        self.write_receipt(name, {"state": "running", "signature": signature, "argv": argv,
+                                  "resource": resource, "at": stamp(), "previous_outputs": previous_outputs,
+                                  "execution": execution})
+        self.event(name, "running", resource=resource)
+        t0 = time.monotonic()
+        try:
+            with (self.root / "logs" / f"{name}.log").open("a") as log:
+                result = subprocess.run(command, cwd=self.root, stdout=log, stderr=subprocess.STDOUT,
+                                        env=self._execution_environment())
+            elapsed = time.monotonic() - t0
+            if result.returncode:
+                raise subprocess.CalledProcessError(result.returncode, command)
+            self.record_completed(name, signature, outputs, elapsed, execution=execution, argv=argv,
+                                  previous_outputs=previous_outputs)
+        except BaseException as exc:
+            self.write_receipt(name, {"state": "failed", "signature": signature, "at": stamp(),
+                                      "error": str(exc), "seconds": time.monotonic() - t0,
+                                      "execution": execution, "argv": argv})
+            self.event(name, "failed", error=str(exc))
+            raise
+        self.event(name, "completed", seconds=elapsed)
+        return True