Archive 4 checkpoints (1-4)

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

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""CPU frozen-annotator composition on the exact Figure 2 P/C selected readout.
+
+The existing P/C table is immutable. Every selected row and Poisson-count hash
+must match its receipt before a separate composition table can be produced.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import json
+import os
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+import h5py
+import numpy as np
+import pandas as pd
+from scipy import sparse
+
+import rescore_pretrain_ablations as pc
+
+ROOT = pc.ROOT
+WORK = ROOT / "work/ablation_composition_v1"
+REBUILD = pc.MODEL / "plans/aifi_scanvi_rebuild_20260916"
+MODEL = REBUILD / "runs/aifi_scanvi_f01common_v1/scanvi_model"
+TRUTH_LABELS = pc.PANEL / "labels/truth_target/labels.parquet"
+TRUTH_LABEL_MANIFEST = TRUTH_LABELS.with_name("labels.manifest.json")
+PC_RECEIPT = ROOT / "source_data/ablation_pretrain_pc_receipt.json"
+PC_CSV = ROOT / "source_data/ablation_pretrain_pc.csv"
+SCANVI_PY = Path("/home/sj_server_1/miniforge3/envs/scanvi/bin/python")
+DATASET = "004_A_GSE135779_SLE_PBMC"
+LABELS = ["T cell", "B cell", "Monocyte", "NK cell", "DC", "Other"]
+
+
+def sha_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(8 * 1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def file_record(path: Path) -> dict:
+    before = path.stat()
+    digest = sha_file(path)
+    after = path.stat()
+    if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
+        raise ValueError(f"source changed during hashing: {path}")
+    return {"path": str(path), "sha256": digest, "bytes": after.st_size}
+
+
+def assert_array_hash(array: np.ndarray, expected: str, name: str) -> None:
+    if pc.sha_array(array) != expected:
+        raise ValueError(f"{name}: reconstructed array differs from the P/C receipt")
+
+
+def decode_obs(group) -> np.ndarray:
+    if isinstance(group, h5py.Group):
+        categories = np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in group["categories"][:]])
+        codes = group["codes"][:]
+        if (codes < 0).any():
+            raise ValueError("missing categorical observation")
+        return categories[codes]
+    return np.asarray([x.decode() if isinstance(x, bytes) else str(x) for x in group[:]])
+
+
+def align_truth_labels(frame: pd.DataFrame, truth_donors: np.ndarray) -> np.ndarray:
+    if frame["cell_index"].duplicated().any():
+        raise ValueError("truth label cell_index is not unique")
+    index = frame["cell_index"].to_numpy()
+    if len(index) != len(truth_donors) or set(index) != set(range(len(truth_donors))):
+        raise ValueError("truth labels must cover every original cell row exactly once")
+    ordered = frame.set_index("cell_index").loc[np.arange(len(truth_donors))]
+    if not np.array_equal(ordered["sample_id"].to_numpy(), truth_donors):
+        raise ValueError("truth label donor identity differs from the H5AD row")
+    return ordered["celltype_l1_pred"].to_numpy(dtype=str)
+
+
+def composition_rows(reference: np.ndarray, candidate: np.ndarray,
+                     reference_donors: np.ndarray, candidate_donors: np.ndarray,
+                     donors: list[str], labels: list[str]) -> tuple[list[dict], list[dict]]:
+    if set(reference) - set(labels) or set(candidate) - set(labels):
+        raise ValueError("unrecognized composition label")
+    if len(reference) != len(reference_donors) or len(candidate) != len(candidate_donors):
+        raise ValueError("cell and donor arrays have different lengths")
+    summary, proportions = [], []
+    for donor in donors:
+        real = reference[reference_donors == donor]
+        generated = candidate[candidate_donors == donor]
+        if not len(real) or not len(generated):
+            raise ValueError(f"{donor}: no reference or candidate cells")
+        pr = np.asarray([np.mean(real == label) for label in labels])
+        pg = np.asarray([np.mean(generated == label) for label in labels])
+        summary.append({"donor": donor, "comp_l1": float(np.abs(pr - pg).sum()),
+                        "n_reference": len(real), "n_candidate": len(generated)})
+        proportions.extend({"donor": donor, "cell_type": label, "observed_fraction": float(r),
+                            "candidate_fraction": float(g)} for label, r, g in zip(labels, pr, pg))
+    return summary, proportions
+
+
+def verify_records(records: dict) -> None:
+    for name, record in records.items():
+        if sha_file(Path(record["path"])) != record["sha256"]:
+            raise ValueError(f"changed bound input: {name}")
+
+
+def prepare() -> dict:
+    import anndata as ad
+
+    complete = WORK / "PREPARED.json"
+    if complete.exists():
+        receipt = json.loads(complete.read_text())
+        verify_records(receipt["inputs"])
+        verify_records(receipt["outputs"])
+        return receipt
+    if WORK.exists() and any(WORK.iterdir()):
+        raise FileExistsError(f"partial analysis exists; preserve and inspect before retry: {WORK}")
+    WORK.mkdir(parents=True, exist_ok=True)
+    old = json.loads(PC_RECEIPT.read_text())
+    if old["schema"] != "pbisc.fig2.pretrain_pc.v1" or old["recipe"]["per_donor_per_set"] != 100:
+        raise ValueError("unexpected P/C recipe")
+    ids = pc.panel_gene_ids()
+    assert_array_hash(np.asarray(ids, dtype="S20"), old["gene_axis"]["ids_sha256"], "gene axis")
+    truth_manifest = json.loads(TRUTH_LABEL_MANIFEST.read_text())
+    if truth_manifest["target_truth_used_for_fitting"] or truth_manifest["query_train_epochs"] != 0:
+        raise ValueError("truth annotation was not frozen")
+    model_record = file_record(MODEL / "model.pt")
+    if model_record["sha256"] != truth_manifest["model"]["model_pt_sha256"]:
+        raise ValueError("frozen annotator differs from the existing truth-label model")
+    with h5py.File(pc.TRUTH) as f:
+        truth_donors = decode_obs(f["obs/donor_id"])
+    truth_labels = align_truth_labels(pd.read_parquet(TRUTH_LABELS), truth_donors)
+    inputs = {"pc_receipt": file_record(PC_RECEIPT), "pc_csv": file_record(PC_CSV),
+              "truth": file_record(pc.TRUTH), "truth_labels": file_record(TRUTH_LABELS),
+              "truth_label_manifest": file_record(TRUTH_LABEL_MANIFEST), "model": model_record,
+              "annotator": file_record(REBUILD / "predict_scanvi.py"),
+              "annotator_common": file_record(REBUILD / "scanvi_common.py"),
+              "gene_mapping": file_record(pc.GENES_TSV), "pc_script": file_record(Path(pc.__file__)),
+              "composition_script": file_record(Path(__file__))}
+    matrices, mapping_rows, selected = [], [], {}
+    families = {}
+    shared = None
+    cursor = 0
+    for family, specs in pc.family_specs().items():
+        evidence = old["families"][family]
+        if evidence["status"] != "complete":
+            raise ValueError(f"{family}: P/C family incomplete")
+        donors = evidence["donor_ids"]
+        r1, r2 = pc.balanced_real_split(truth_donors, donors, 100, pc.SEED)
+        assert_array_hash(r1, evidence["real_R1_rows_sha256"], "real R1 rows")
+        assert_array_hash(r2, evidence["real_R2_rows_sha256"], "real R2 rows")
+        if shared is None:
+            shared = (donors, r1, r2)
+            truth_cols = pc.gene_columns(pc.benchmark_gene_ids(), ids)
+            real = pc.load_real(np.concatenate([r1, r2]), truth_cols)
+            for method, counts, rows in zip(["real_R1", "real_R2_independent"], np.split(real, 2), [r1, r2]):
+                selected[method] = counts
+                matrices.append(sparse.csr_matrix(counts))
+                mapping_rows.extend({"query_row": cursor + i, "family": "shared_real", "method": method,
+                                     "donor": str(truth_donors[row]), "source_row": int(row),
+                                     "existing_truth_label": str(truth_labels[row])} for i, row in enumerate(rows))
+                cursor += len(rows)
+            del real
+        elif donors != shared[0] or not np.array_equal(r1, shared[1]) or not np.array_equal(r2, shared[2]):
+            raise ValueError("families do not share the exact real donor/cell reference")
+        families[family] = {"donor_ids": donors, "real_R1_rows_sha256": pc.sha_array(r1),
+                            "real_R2_rows_sha256": pc.sha_array(r2), "methods": {}}
+        for method, source in specs:
+            print(f"hashing and reconstructing {family}/{method}", flush=True)
+            record = file_record(source)
+            generated_receipt_path = source.with_suffix(".log")
+            if generated_receipt_path.exists():
+                generated_receipt = json.loads(generated_receipt_path.read_text())
+                if generated_receipt.get("output_sha256") != record["sha256"]:
+                    raise ValueError(f"generation receipt SHA does not match: {source}")
+                record["generation_receipt"] = file_record(generated_receipt_path)
+            inputs[method] = record
+            meta = pc.npz_metadata(source)
+            if meta["sample_ids"] != donors:
+                raise ValueError(f"{method}: changed donor order")
+            rows = pc.selected_generated_rows(meta["bulk_index"], len(donors), 100, pc.SEED)
+            assert_array_hash(rows, evidence["generated_rows_sha256"], "generated rows")
+            cols = pc.gene_columns(meta["gene_ids"], ids)
+            rates = pc.stream_selected_npz(source, rows, cols)
+            counts = np.random.default_rng(pc.POISSON_SEED).poisson(rates).astype(np.float32)
+            assert_array_hash(counts, evidence["source_files"][method]["selected_poisson_counts_sha256"], method)
+            selected[method] = counts
+            matrices.append(sparse.csr_matrix(counts))
+            donor_rows = np.asarray(donors)[meta["bulk_index"][rows]]
+            mapping_rows.extend({"query_row": cursor + i, "family": family, "method": method,
+                                 "donor": str(donor_rows[i]), "source_row": int(row),
+                                 "existing_truth_label": ""} for i, row in enumerate(rows))
+            cursor += len(rows)
+            families[family]["methods"][method] = {"selected_rows_sha256": pc.sha_array(rows),
+                                                     "selected_poisson_counts_sha256": pc.sha_array(counts)}
+    mapping = pd.DataFrame(mapping_rows)
+    mapping.to_csv(WORK / "query_rows.csv", index=False)
+    obs = pd.DataFrame({"sample_id": mapping["donor"].to_numpy(), "source": mapping["method"].to_numpy(),
+                        "batch_key": (DATASET + "_" + mapping["donor"]).to_numpy()},
+                       index=[f"selected_{i}" for i in range(cursor)])
+    query = ad.AnnData(X=sparse.vstack(matrices, format="csr"), obs=obs,
+                       var=pd.DataFrame(index=ids))
+    query.uns["query_build"] = {"kind": "exact_pc_selected_readout", "pc_receipt_sha256": inputs["pc_receipt"]["sha256"],
+                                 "poisson_seed": pc.POISSON_SEED, "real_cells_untouched": True}
+    query.write_h5ad(WORK / "selected_readout.h5ad", compression="gzip")
+    np.savez_compressed(WORK / "selected_counts.npz", **selected, gene_ids=np.asarray(ids), donor_ids=np.asarray(shared[0]))
+    result = {"schema": "pbisc.fig2.ablation-composition-inputs.v1", "status": "complete",
+              "created_at_utc": datetime.now(timezone.utc).isoformat(), "inputs": inputs,
+              "families": families, "n_query_rows": cursor,
+              "outputs": {name: file_record(WORK / name) for name in ["query_rows.csv", "selected_readout.h5ad", "selected_counts.npz"]}}
+    complete.write_text(json.dumps(result, indent=2) + "\n")
+    return result
+
+
+def annotate() -> None:
+    prepared = json.loads((WORK / "PREPARED.json").read_text())
+    verify_records(prepared["outputs"])
+    output = WORK / "annotation"
+    if output.exists():
+        raise FileExistsError(f"annotation already exists; preserve before retry: {output}")
+    env = dict(os.environ, CUDA_VISIBLE_DEVICES="", OMP_NUM_THREADS="2", MKL_NUM_THREADS="2", OPENBLAS_NUM_THREADS="2", PYTHONNOUSERSITE="1")
+    command = [str(SCANVI_PY), str(REBUILD / "predict_scanvi.py"), "--model-dir", str(MODEL),
+               "--query", str(WORK / "selected_readout.h5ad"), "--out-dir", str(output),
+               "--method-name", "ablation_pc_selected_readout", "--dataset-id", DATASET,
+               "--split", "primary_kmeans", "--sample-id-col", "sample_id", "--batch-key-col", "batch_key",
+               "--seed", str(pc.POISSON_SEED), "--device", "cpu", "--num-threads", "2", "--eval-batch-size", "2048"]
+    with (WORK / "annotation.log").open("w") as log:
+        subprocess.run(command, env=env, check=True, stdout=log, stderr=subprocess.STDOUT)
+    (WORK / "ANNOTATION_RUN.json").write_text(json.dumps({"command": command, "device": "cpu",
+         "query_sha256": prepared["outputs"]["selected_readout.h5ad"]["sha256"],
+         "labels": file_record(output / "labels.parquet"), "manifest": file_record(output / "labels.manifest.json")}, indent=2) + "\n")
+
+
+def summarize() -> dict:
+    output_receipt = ROOT / "source_data/ablation_pretrain_composition_receipt.json"
+    if output_receipt.exists():
+        raise FileExistsError("composition already complete; preserve existing version")
+    prepared = json.loads((WORK / "PREPARED.json").read_text())
+    verify_records(prepared["inputs"])
+    verify_records(prepared["outputs"])
+    annotation_run = json.loads((WORK / "ANNOTATION_RUN.json").read_text())
+    verify_records({key: annotation_run[key] for key in ["labels", "manifest"]})
+    manifest = json.loads((WORK / "annotation/labels.manifest.json").read_text())
+    if manifest["device"] != "cpu" or manifest["query_train_epochs"] != 0 or manifest["target_truth_used_for_fitting"]:
+        raise ValueError("annotator is not frozen CPU prediction")
+    if manifest["model"]["model_pt_sha256"] != prepared["inputs"]["model"]["sha256"]:
+        raise ValueError("changed annotation model")
+    if manifest["gene_space"]["model_genes_missing_from_query_zero_padded"] != 0:
+        raise ValueError("missing annotator genes")
+    mapping = pd.read_csv(WORK / "query_rows.csv", keep_default_na=False)
+    labels = pd.read_parquet(WORK / "annotation/labels.parquet")
+    if labels["npz_row"].duplicated().any() or set(labels["npz_row"]) != set(mapping["query_row"]):
+        raise ValueError("annotation does not cover query rows exactly once")
+    labels = labels.set_index("npz_row").loc[mapping["query_row"]].reset_index()
+    if not np.array_equal(labels["sample_id"].to_numpy(), mapping["donor"].to_numpy()):
+        raise ValueError("annotated donor identity mismatch")
+    if not np.array_equal(labels["source"].to_numpy(), mapping["method"].to_numpy()):
+        raise ValueError("annotated method identity mismatch")
+    mapping["label"] = labels["celltype_l1_pred"].to_numpy()
+    real_rows = mapping["family"] == "shared_real"
+    concordance = float(np.mean(mapping.loc[real_rows, "label"] == mapping.loc[real_rows, "existing_truth_label"]))
+    if concordance < 0.99:
+        raise ValueError(f"selected real annotation differs materially from original labels: {concordance}")
+    reference = mapping[mapping["method"] == "real_R1"]
+    rows, proportions = [], []
+    for family, evidence in prepared["families"].items():
+        for method in ["real_R2_independent", *evidence["methods"]]:
+            candidate = mapping[mapping["method"] == method]
+            summary, detail = composition_rows(reference["label"].to_numpy(), candidate["label"].to_numpy(),
+                reference["donor"].to_numpy(), candidate["donor"].to_numpy(), evidence["donor_ids"], LABELS)
+            rows.extend({"family": family, "method": method, **row} for row in summary)
+            proportions.extend({"family": family, "method": method, **row} for row in detail)
+    table = pd.DataFrame(rows)
+    table.to_csv(ROOT / "source_data/ablation_pretrain_composition.csv", index=False)
+    pd.DataFrame(proportions).to_csv(ROOT / "source_data/ablation_pretrain_composition_proportions.csv", index=False)
+    aggregate = table.groupby(["family", "method"], sort=False)["comp_l1"].agg(["mean", "std", "count"]).reset_index()
+    aggregate.columns = ["family", "method", "comp_l1_mean", "comp_l1_sd", "n_donors"]
+    aggregate.to_csv(ROOT / "source_data/ablation_pretrain_composition_summary.csv", index=False)
+    receipt = {"schema": "pbisc.fig2.ablation-composition.v1", "status": "complete",
+        "created_at_utc": datetime.now(timezone.utc).isoformat(), "prepared_inputs": file_record(WORK / "PREPARED.json"),
+        "inputs": prepared["inputs"], "selected_readout": prepared["outputs"],
+        "annotation": {"run": file_record(WORK / "ANNOTATION_RUN.json"), **annotation_run},
+        "recipe": {"reference": "the same 4200 real R1 cells used to fit P/C geometry",
+            "candidate": "100 cells per donor; exact P/C selected arrays verified by SHA256",
+            "real_control": "independent 4200 real R2 cells; same observed R1 reference",
+            "classifier": manifest["classifier"], "classifier_fitting": "external AIFI only; zero query training",
+            "label_space": LABELS, "classifier_gene_space": manifest["gene_space"],
+            "readout": "same selected 1006-gene Poisson integer counts as P/C; real counts untouched",
+            "summary": "unweighted mean of donor L1 errors; L1=sum over all six label fractions",
+            "biological_unit": "donor", "sampling_seed": pc.SEED, "poisson_seed": pc.POISSON_SEED,
+            "families_separate": True, "real_label_concordance_with_original_frozen_annotation": concordance},
+        "limitations": ["Single 100-cell draw per donor; donor sampling noise is shown by the independent real R2 control.",
+            "Architecture 1% and gene-panel 0.1% floors remain separate comparisons.",
+            "Composition describes frozen-annotator categories, not manual ground-truth identities.",
+            "The fixed AIFI annotator consumes 1005 of the 1006 measured P/C genes; no missing genes are fabricated."],
+        "outputs": {name: file_record(ROOT / "source_data" / name) for name in [
+            "ablation_pretrain_composition.csv", "ablation_pretrain_composition_proportions.csv", "ablation_pretrain_composition_summary.csv"]}}
+    output_receipt.write_text(json.dumps(receipt, indent=2) + "\n")
+    print(aggregate.to_string(index=False), flush=True)
+    return receipt
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--stage", choices=["prepare", "annotate", "summarize", "all"], default="all")
+    args = parser.parse_args(argv)
+    if args.stage in ["prepare", "all"]:
+        prepare()
+        gc.collect()
+    if args.stage in ["annotate", "all"]:
+        annotate()
+    if args.stage in ["summarize", "all"]:
+        summarize()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""Create an immutable, scoped task snapshot/request; never prepare or publish.
+
+Generated arrays remain location-only. A snapshot is not a scientific-completion
+claim: draft code and manuscripts retain intermediate state. This helper reads
+only the named Figure 1--5 task and its three explicitly adapted legacy files.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+from pathlib import Path
+import re
+import shutil
+import subprocess
+
+PLAN = Path(__file__).resolve().parents[1]
+MODEL8 = PLAN.parents[1]
+RELEASE = Path('/home/sj_server_1/PBISC/paper-release-20260928')
+ID_RE = re.compile(r'[0-9]{8}T[0-9]{6}Z-[a-z0-9-]+\Z')
+SKIP_PARTS = {'.git', '__pycache__', '.pytest_cache', 'runtime_env', 'Rlib'}
+PREVIEW_NOTE = ('Restructuring PREVIEW; strict experiments/derived panels remain '
+                'incomplete. This is not a final manuscript or final Figure 1--5 set.')
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def fingerprint(path: Path) -> tuple[int, int, int, int]:
+    if path.is_symlink() or any(p.is_symlink() for p in path.parents):
+        raise ValueError(f'symlink refused: {path}')
+    s = path.stat()
+    if not path.is_file():
+        raise ValueError(f'not a regular file: {path}')
+    return s.st_dev, s.st_ino, s.st_size, s.st_mtime_ns
+
+
+def stable_hash(path: Path) -> str:
+    before = fingerprint(path)
+    value = sha(path)
+    if fingerprint(path) != before:
+        raise RuntimeError(f'file changed during hash: {path}')
+    return value
+
+
+def files_under(folder: Path):
+    return sorted(p for p in folder.rglob('*')
+                  if p.is_file() and not any(x in SKIP_PARTS for x in p.parts))
+
+
+def json_load(path: Path):
+    return json.loads(path.read_text())
+
+
+def write_json(path: Path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('x') as f:
+        json.dump(value, f, indent=2, ensure_ascii=False)
+        f.write('\n')
+
+
+def observation(argv):
+    result = subprocess.run(argv, capture_output=True, text=True, timeout=30)
+    return {'argv': argv, 'returncode': result.returncode,
+            'stdout': result.stdout.strip(), 'stderr': result.stderr.strip()}
+
+
+def operation_state(name: str) -> str:
+    path = PLAN / 'receipts' / f'{name}.json'
+    if not path.is_file():
+        return 'planned'
+    state = json_load(path).get('state')
+    return state if state in {'running', 'failed'} else 'planned'
+
+
+def completion_gate() -> None:
+    final = json_load(PLAN / 'FINALIZATION_STATUS.json')
+    if final.get('stage') != 'all' or final.get('state') not in {'complete', 'completed'}:
+        raise ValueError('complete archive requires successful all-stage finalization')
+    from assemble_manuscript import strict_gate
+    gaps, _ = strict_gate()
+    if gaps:
+        raise ValueError('complete archive strict gates failed: ' + '; '.join(gaps))
+    if json_load(PLAN / 'manuscript/integration_manifest.json').get('mode') != 'complete':
+        raise ValueError('complete archive cannot contain a preview manuscript')
+    for relative in ['manuscript/main.pdf', 'manuscript/supplementary.pdf',
+                     'deck/paper_figures_final.pptx', 'deck/paper_figures_final.pdf']:
+        if not (PLAN / relative).is_file():
+            raise ValueError(f'missing final document: {relative}')
+
+
+def build(identifier: str, state: str = 'in-progress') -> Path:
+    if not ID_RE.fullmatch(identifier):
+        raise ValueError('invalid update identifier')
+    complete = state == 'complete'
+    if complete:
+        completion_gate()
+    work_state = 'completed' if complete else 'intermediate'
+    work_note = 'Completed source-bound Figure 1--5 campaign; Figure 6 remains reserved' if complete else PREVIEW_NOTE
+    destination = PLAN / 'archive' / identifier
+    destination.mkdir(parents=True, exist_ok=False)
+    payload = destination / 'snapshot'
+    assets, mapping = [], []
+    seen = set()
+
+    def register(path, kind, state, reason, copy=True, relative=None):
+        path = Path(path)
+        if path in seen:
+            return
+        seen.add(path)
+        if not path.is_relative_to(MODEL8) and not path.is_relative_to(RELEASE):
+            raise ValueError(f'outside explicit scope: {path}')
+        before = fingerprint(path)
+        digest = stable_hash(path)
+        archived = path
+        if copy:
+            rel = relative or (path.relative_to(PLAN) if path.is_relative_to(PLAN)
+                               else Path('legacy_adapters') / path.relative_to(MODEL8))
+            # The archive intentionally forbids generated array payload paths;
+            # only their small metadata may be copied, into a named receipt area.
+            rel = Path(*('inference_metadata' if x == 'generated' else x for x in rel.parts))
+            archived = payload / rel
+            archived.parent.mkdir(parents=True, exist_ok=True)
+            if archived.exists():
+                raise ValueError(f'duplicate destination: {archived}')
+            shutil.copy2(path, archived)
+            if fingerprint(path) != before or sha(archived) != digest:
+                raise RuntimeError(f'file changed during snapshot: {path}')
+            archived.chmod(0o444)
+        assets.append({'host': 'server_1', 'source': str(archived),
+                       'kind': kind, 'state': state})
+        mapping.append({'source_host': 'server_1', 'source': str(path),
+                        'snapshot': str(archived), 'sha256': digest,
+                        'bytes': before[2], 'kind': kind, 'state': state,
+                        'reason': reason})
+
+    for sub, kind in [('tools', 'code'), ('tests', 'test')]:
+        for path in files_under(PLAN / sub):
+            if path.suffix in {'.py', '.R'}:
+                register(path, kind, work_state, 'Frozen implementation snapshot; ' + work_note)
+    register(PLAN / 'archive/test_archive_completed.py', 'test', work_state,
+             'Archive-only snapshot negative controls', relative=Path('tests/test_archive_completed.py'))
+    for path in files_under(PLAN / 'protocol'):
+        register(path, 'config', 'completed', 'Exact-pair selection and fixed evaluation contract')
+    for path in files_under(PLAN / 'backups'):
+        if path.suffix in {'.json', '.py'}:
+            register(path, 'code' if path.suffix == '.py' else 'provenance', 'stopped',
+                     'Preserved earlier adapter/receipt or rejected prelaunch contract; not an active scientific input')
+    for path in sorted((PLAN / 'deconvolution').rglob('INPUTS.json')):
+        register(path, 'provenance', 'completed', 'Prepared exact-support deconvolution inputs; method runs may still be pending')
+        support = path.with_name('SUPPORT.json')
+        if support.is_file():
+            register(support, 'metadata', 'completed', 'Deconvolution reference/mixture support')
+    for path in files_under(PLAN / 'data'):
+        if path.suffix == '.npz':
+            if path.name not in {'test_raw.npz', 'test_cal.npz', 'conditions_raw.npz', 'conditions_refcal.npz'}:
+                raise ValueError(f'unexpected condition array: {path}')
+            register(path, 'condition', 'completed', 'Immutable prepared condition; no generated array', copy=False)
+        elif path.suffix == '.npy':
+            if path.name != 'alpha.npy':
+                raise ValueError(f'unexpected fitted data array: {path}')
+            register(path, 'data', 'completed', 'Exact-support or external-reference calibration coefficients', copy=False)
+        elif path.suffix in {'.json', '.txt', '.csv'}:
+            register(path, 'metadata', 'completed', 'Condition construction / sample selection provenance')
+    for path in files_under(PLAN / 'source_data'):
+        completed = complete or path.name.startswith(('ablation_pretrain', 'fig1_'))
+        register(path, 'table' if path.suffix == '.csv' else 'provenance',
+                 'completed' if completed else 'intermediate',
+                 'Completed native-pseudobulk rescore / corpus data' if completed else PREVIEW_NOTE)
+    composition_receipt = PLAN / 'source_data/ablation_pretrain_composition_receipt.json'
+    if composition_receipt.is_file() and json_load(composition_receipt).get('status') == 'complete':
+        for path in files_under(PLAN / 'work/ablation_composition_v1'):
+            register(path, 'data' if path.suffix in {'.npz', '.h5ad', '.parquet'} else 'provenance',
+                     'completed', 'Exact P/C selected cells and frozen CPU annotations for composition')
+    for path in files_under(PLAN / 'reports'):
+        completed = complete or path.name.startswith(('figure1_', 'ablation_pretrain'))
+        register(path, 'report', 'completed' if completed else 'intermediate',
+                 'Completed figure/source provenance' if completed else PREVIEW_NOTE)
+    for path in files_under(PLAN / 'figures'):
+        ready = complete or path.name.startswith('fig1_')
+        diagnostic = 'diagnostic' in path.name
+        register(path, 'figure', 'completed' if ready and not diagnostic else 'intermediate',
+                 'Complete inference/corpus concept figure' if path.name.startswith('fig1_') else work_note)
+    for sub, kind in [('deck', 'document'), ('manuscript', 'manuscript')]:
+        for path in files_under(PLAN / sub):
+            preview = sub == 'deck' and path.name.startswith('paper_figures_review')
+            register(path, kind, 'intermediate' if preview else work_state,
+                     PREVIEW_NOTE if preview else work_note)
+    for path in files_under(PLAN / 'scores_pilot'):
+        register(path, 'report', 'intermediate', 'Pilot two-arm score only; not full five-arm final evaluation')
+    # Final strict scores and deconvolution sources are limited to completed
+    # per-unit evidence. The large NPZ/readout caches remain original-location data.
+    if complete:
+        for sub in ['scores', 'deconvolution']:
+            for path in files_under(PLAN / sub):
+                if path.suffix in {'.csv', '.tsv', '.json', '.txt', '.R'}:
+                    register(path, 'provenance' if path.suffix == '.json' else 'table',
+                             'completed', 'Completed strict-support source data and inference provenance')
+    else:
+        for path in sorted((PLAN / 'protocol/splits').rglob('support.json')):
+            relative = path.parent.relative_to(PLAN / 'protocol/splits')
+            receipt = PLAN / 'receipts' / ('-'.join(relative.parts) + '-score.json')
+            if not receipt.is_file() or json_load(receipt).get('state') != 'completed':
+                continue
+            for scored in files_under(PLAN / 'scores' / relative):
+                if scored.suffix in {'.csv', '.tsv', '.json', '.txt'}:
+                    register(scored, 'provenance' if scored.suffix == '.json' else 'table',
+                             'completed', 'Completed five-arm unit; full campaign still pending')
+    for path in sorted((PLAN / 'receipts').glob('*.json')):
+        receipt = json_load(path)
+        if receipt.get('state') == 'completed':
+            rejected = path.name == 'prepare-strict-conditions.json'
+            register(path, 'provenance', 'stopped' if rejected else 'completed',
+                     'Superseded v1 preparation receipt; not an active input' if rejected else 'Completed operation receipt')
+    for name in ['PLAN.md', 'PROGRESS.md', 'CAMPAIGN_STATUS.json', 'FINALIZATION_STATUS.json', 'events.jsonl']:
+        if (PLAN / name).exists():
+            register(PLAN / name, 'report', 'intermediate', 'Point-in-time task observation, not final completion')
+    for path in [MODEL8 / 'plans/paired_finetune_intradataset_20260927/tools/ft_sdd.py',
+                 MODEL8 / 'plans/paired_finetune_intradataset_20260927/scsemi/tools/prepare_draw_inputs.py',
+                 MODEL8 / 'plans/paired_finetune_intradataset_20260927/scsemi/tools/export_npz.py']:
+        register(path, 'code', 'intermediate', 'Explicit opt-in strict-support adapter; original mode preserved')
+
+    # Models are included only behind completed operation receipts, never from
+    # filename presence or incomplete controller progress alone.
+    for train_receipt in sorted((PLAN / 'receipts').glob('*-train.json')):
+        trained = json_load(train_receipt)
+        if trained.get('state') != 'completed':
+            continue
+        expected = {o['path']: o['sha256'] for o in trained['outputs']}
+        checkpoints = [Path(x) for x in expected if Path(x).suffix == '.pt']
+        for checkpoint in checkpoints:
+            if not checkpoint.is_relative_to(PLAN / 'runs'):
+                raise ValueError('training receipt outside strict campaign')
+            for path in files_under(checkpoint.parent):
+                if str(path) in expected and stable_hash(path) != expected[str(path)]:
+                    raise ValueError(f'model receipt mismatch: {path}')
+                register(path, 'checkpoint' if path.suffix == '.pt' else 'provenance',
+                         'completed', 'Completed exact-support LoRA adaptation', copy=path.suffix != '.pt')
+    completed_sc = []
+    for adoption in sorted((PLAN / 'scsemi').rglob('ADOPTION.json')):
+        work = adoption.parent.parent
+        relative = work.relative_to(PLAN / 'scsemi')
+        exported = PLAN / 'generated' / relative / 'scsemi.log'
+        if not exported.is_file() or json_load(exported).get('schema') != 'pbisc.scsemi.adopted-output.v1':
+            continue
+        proof = json_load(exported)
+        if proof.get('adoption_receipt_sha256') != stable_hash(adoption):
+            raise ValueError('adopted scSemi output proof changed')
+        for path in files_under(work):
+            if path.suffix == '.json':
+                register(path, 'provenance', 'completed', 'Audited same-budget legacy adoption; no new native strict GPU work claimed')
+    for status_path in sorted((PLAN / 'scsemi').rglob('status.json')):
+        sc_status = json_load(status_path)
+        if not (sc_status.get('pretrain_complete') and sc_status.get('infer_complete')):
+            continue
+        sc = status_path.parent
+        completed_sc.append(sc)
+        for path in files_under(sc):
+            if path.suffix == '.json':
+                register(path, 'provenance', 'completed', 'Completed exact-support scSemi provenance')
+            elif path.parent == sc / 'scsemi_project/models' and not path.suffix:
+                register(path, 'data', 'completed', 'Baseline scSemi weights; private dataset payload, not PBISC model release', copy=False)
+
+    locations = []
+    for support in sorted((PLAN / 'protocol/splits').rglob('support.json')):
+        relative = support.parent.relative_to(PLAN / 'protocol/splits')
+        for arm in ['lora', 'pairedcal', 'scsemi']:
+            path = PLAN / 'generated' / relative / f'{arm}.npz'
+            log = path.with_suffix('.log')
+            row = {'host': 'server_1', 'path': str(path),
+                   'state': operation_state('-'.join(relative.parts) + '-' + arm),
+                   'cohort': relative.parts[0], 'experiment': f'strict_pairs/{relative}/{arm}',
+                   'support_manifest': str(support), 'support_sha256': stable_hash(support),
+                   'note': 'Exact support contract; no completion inferred from presence alone'}
+            if path.exists() and log.exists():
+                try:
+                    info = json_load(log)
+                except json.JSONDecodeError:
+                    row.update(state='presence_only', note='Output or log exists but completed generation receipt is unavailable')
+                    locations.append(row)
+                    continue
+                digest = info.get('output_sha256')
+                if not digest:
+                    raise ValueError(f'completed output log lacks SHA: {log}')
+                register(log, 'provenance', 'completed', 'Immutable completed generation receipt')
+                receipt_copy = next(x['snapshot'] for x in mapping if x['source'] == str(log))
+                row.update(state='completed', receipt=receipt_copy, generation_log=str(log),
+                           sha256=digest, output_sha256=digest,
+                           **{k: info[k] for k in ['checkpoint_sha256', 'condition_sha256', 'checkpoint', 'condition_npz', 'bulks', 'cells', 'genes', 'seed', 'steps', 'weights'] if k in info})
+                row['note'] = 'Completed generated array retained in place; SHA from immutable generation receipt'
+                if path.with_suffix('.validation.json').exists():
+                    register(path.with_suffix('.validation.json'), 'provenance', 'completed', 'scSemi export validation')
+            locations.append(row)
+    for cohort in ['immicro', 'ye2026_sepsis', 'imperial_eskd', 'giroux2022', 'ji2025_chili']:
+        for arm in ['raw', 'refcal']:
+            path = PLAN / 'generated/global' / cohort / f'{arm}.npz'
+            log = path.with_suffix('.log')
+            row = {'host': 'server_1', 'path': str(path),
+                   'state': operation_state(f'global-{cohort}-{arm}'),
+                   'cohort': cohort, 'experiment': f'strict_pairs/global/{arm}'}
+            if path.exists() and log.exists():
+                try:
+                    info = json_load(log)
+                except json.JSONDecodeError:
+                    row.update(state='presence_only', note='Output or log exists but completed generation receipt is unavailable')
+                    locations.append(row)
+                    continue
+                register(log, 'provenance', 'completed', 'Completed zero-target-sc generation receipt')
+                receipt_copy = next(x['snapshot'] for x in mapping if x['source'] == str(log))
+                row.update(state='completed', receipt=receipt_copy, generation_log=str(log),
+                           sha256=info['output_sha256'], output_sha256=info['output_sha256'],
+                           **{k: info[k] for k in ['checkpoint_sha256', 'condition_sha256', 'checkpoint', 'condition_npz', 'bulks', 'cells', 'genes', 'seed', 'steps', 'weights'] if k in info})
+            locations.append(row)
+    for sc in completed_sc:
+        relative = sc.relative_to(PLAN / 'scsemi')
+        for path in sorted((sc / 'shards').glob('*.json')):
+            info = json_load(path)
+            if info.get('complete'):
+                locations.append({'host': 'server_1', 'path': info['shard'], 'state': 'completed',
+                                  'receipt': next(x['snapshot'] for x in mapping if x['source'] == str(path)),
+                                  'sha256': info['shard_sha256'], 'cohort': relative.parts[0],
+                                  'experiment': f'strict_pairs/{relative}/scsemi_shard',
+                                  'note': 'Lossless CSR inference shard; generated array location only'})
+
+    observed_at = dt.datetime.now(dt.timezone.utc).isoformat()
+    live = {'observed_at': observed_at,
+            'latest_archive': json_load(RELEASE / 'LATEST.json'),
+            'server_1': [observation(['systemctl', '--user', 'is-active', 'ml-memory-guard.service']),
+                         observation(['/home/sj_server_1/.local/libexec/ml-memory-guard', '--check']),
+                         observation(['nvidia-smi', '--query-compute-apps=pid,process_name,used_memory', '--format=csv,noheader']),
+                         observation(['systemctl', '--user', 'list-units', '--all', '--no-pager', 'pbisc-strict-*'])],
+            'server_2': observation(['ssh', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', 'spark-0110',
+                                     'nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv,noheader']),
+            'figure6': 'waiting_user_data_no_execution',
+            'canonical_manuscript': observation(['git', '-C', str(RELEASE / 'manuscript'), 'rev-parse', 'HEAD']),
+            'archive_state': state,
+            'preview_warning': work_note}
+    live_path = destination / 'LIVE_OBSERVATION.json'
+    write_json(live_path, live)
+    assets.append({'host': 'server_1', 'source': str(live_path), 'kind': 'report', 'state': 'intermediate'})
+    provenance_path = destination / 'SNAPSHOT_MANIFEST.json'
+    write_json(provenance_path, {'schema': 'pbisc.strict.archive-snapshot.v1', 'observed_at': observed_at,
+                                'project_id': 'pbisc-diffusion', 'update_id': identifier,
+                                'source_files': mapping, 'archive_state': state, 'preview_warning': work_note})
+    assets.append({'host': 'server_1', 'source': str(provenance_path), 'kind': 'provenance', 'state': 'completed'})
+    request = {'project_id': 'pbisc-diffusion',
+               'summary': ('Figure 1--5 strict-pair implementation checkpoint. Exact-support contracts and prepared conditions; '
+                           'completed Figure 1 and held-out pseudobulk ablation rescoring; completed ImMicro fold0 n5 '
+                           'LoRA/paired-calibration/scSemi outputs and global raw/external-refcal controls. '
+                           'Code, review deck, staged Results/manuscript, and legacy rare-state diagnostics are explicitly '
+                           'INTERMEDIATE PREVIEWS, not final scientific results. The 40-unit campaign and final figure '
+                           'completion remain pending. Large generated arrays remain in place with recorded hashes/receipts. '
+                           'Figure 6 is waiting for user data and has no execution. No GitHub push or Overleaf synchronization.'),
+               'assets': assets, 'inference_locations': locations}
+    if complete:
+        request['summary'] = ('Completed Figure 1--5 strict-pair campaign, quantitative source data, donor-dependent '
+                              'statistics, exact-support deconvolution, rare-state validation, figures, PDF/PPTX, '
+                              'and staged manuscript. Completion gates passed. Model/input/receipt hashes retained. '
+                              'Generated arrays remain original-location references. Figure 6 remains reserved '
+                              'pending user data. No GitHub push or Overleaf synchronization by this archive helper.')
+    request_path = destination / 'request.json'
+    write_json(request_path, request)
+    for path in [live_path, provenance_path, request_path]:
+        path.chmod(0o444)
+    print(json.dumps({'request': str(request_path), 'assets': len(assets), 'locations': len(locations),
+                      'payload_bytes': sum(Path(x['source']).stat().st_size for x in assets),
+                      'completed_locations': sum(x['state'] == 'completed' for x in locations)}))
+    return request_path
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--id', required=True)
+    parser.add_argument('--state', choices=['in-progress', 'complete'], default='in-progress')
+    args = parser.parse_args()
+    build(args.id, args.state)

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

@@ -0,0 +1,565 @@
+#!/usr/bin/env python3
+"""Stage the PBISC-Diffusion Figure 1--5 manuscript without changing its Git tree.
+
+--preview emits an explicitly incomplete review draft. --require-complete refuses
+until every strict unit and its source binding has been verified, then uses the
+same staged file map. No Git, archive or network write is performed here.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+CANON = Path('/home/sj_server_1/PBISC/paper-release-20260928/manuscript')
+STAGE = ROOT / 'manuscript'
+EDITS = STAGE / 'edits'
+COHORTS = ('ye2026_sepsis', 'imperial_eskd', 'giroux2022', 'ji2025_chili')
+FIGURES = {
+    'fig1_overview.pdf': 'fig1_overview.pdf',
+    'fig2_ablation_and_support.pdf': 'fig2_ablation_and_support.pdf',
+    'fig4_historical_5fold_separate.pdf': 'fig4_historical_5fold_separate.pdf',
+}
+FINAL_FIGURES = {
+    'fig3_healthy_strict_oof.pdf': 'fig3_healthy_strict_oof.pdf',
+    'fig3_realism_metrics.pdf': 'fig3_realism_metrics.pdf',
+    'fig3_canonical_marker_dotplot.pdf': 'fig3_canonical_marker_dotplot.pdf',
+    'fig3_umap_by_celltype.pdf': 'fig3_umap_by_celltype.pdf',
+    'fig3_composition_fractions.pdf': 'fig3_composition_fractions.pdf',
+    'fig3_runtime_components.pdf': 'fig3_runtime_components.pdf',
+    'fig4_disease_strict_draws.pdf': 'fig4_disease_strict_draws.pdf',
+    'fig4_disease_signal_strict.pdf': 'fig4_disease_signal_strict.pdf',
+    'fig4_disease_signal_scatter.pdf': 'fig4_disease_signal_scatter.pdf',
+    'fig4_disease_signal_heatmap.pdf': 'fig4_disease_signal_heatmap.pdf',
+    'fig4_disease_signal_cat.pdf': 'fig4_disease_signal_cat.pdf',
+    'fig4_deconvolution_strict.pdf': 'fig4_deconvolution_strict.pdf',
+    'fig4_deconvolution_expression_strict.pdf': 'fig4_deconvolution_expression_strict.pdf',
+    'fig5_rare_states_strict.pdf': 'fig5_rare_states_strict.pdf',
+    'fig5_rare_visuals_strict.pdf': 'fig5_rare_visuals_strict.pdf',
+    'fig5_all_states_strict.pdf': 'fig5_all_states_strict.pdf',
+    'fig5_behcet_rules_strict.pdf': 'fig5_behcet_rules_strict.pdf',
+}
+
+
+def digest(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def document(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def rows(path: Path) -> list[dict[str, str]]:
+    with path.open(newline='') as f:
+        return list(csv.DictReader(f))
+
+
+def tracked_sources() -> list[Path]:
+    raw = subprocess.check_output(['git', '-C', str(CANON), 'ls-files', '-z'])
+    paths = [Path(p.decode()) for p in raw.split(b'\0') if p]
+    wanted = {'.tex', '.bib', '.cls', '.bst'}
+    return [p for p in paths if p.suffix in wanted or
+            (p.parts[0] == 'figures' and p.suffix.lower() in {'.pdf', '.png'})]
+
+
+def checked_provenance(path: Path, label: str) -> dict:
+    if not path.is_file():
+        raise ValueError(f'{label}: missing {path}')
+    item = document(path)
+    for entry in item.get('sources', []) + item.get('outputs', []):
+        source = Path(entry['path'])
+        if not source.is_file() or digest(source) != entry['sha256']:
+            raise ValueError(f'{label}: source/output hash mismatch: {source}')
+    return item
+
+
+def strict_gate() -> tuple[list[str], dict]:
+    gaps = []
+    readiness_path = ROOT / 'reports/figures234_readiness.json'
+    readiness = document(readiness_path) if readiness_path.is_file() else {}
+    if readiness.get('schema') != 'pbisc.paper.figures234.v1' or readiness.get('status') != 'complete':
+        gaps.append('Figures 2--4 readiness is not complete')
+    f2, f3, f4 = (readiness.get(k, {}) for k in ('figure2', 'figure3', 'figure4'))
+    if f2.get('strict_complete_units') != 20 or f2.get('strict_missing') or not f2.get('pretrain_composition_ready'):
+        gaps.append('Figure 2 needs 20/20 strict healthy support units')
+    if (f3.get('strict_complete_folds') != 5 or not f3.get('visual_export_ready') or
+            not f3.get('extras_complete') or not f3.get('runtime_ready')):
+        gaps.append('Figure 3 needs 5/5 folds, visual, extras and time receipts')
+    if (set(f4.get('strict_complete_draws', {})) != set(COHORTS) or
+            any(f4['strict_complete_draws'].get(c) != 5 for c in COHORTS) or
+            any(f4.get(k) for k in ('contrast_missing', 'deconvolution_missing',
+                                    'deconvolution_signal_missing'))):
+        gaps.append('Figure 4 needs 5/5 strict draws per cohort and contrast/deconvolution evidence')
+    expected_healthy = {(f'fold{fold}', n) for fold in range(5) for n in (5, 10, 20, 40)}
+    expected_disease = {(c, f'draw{draw}') for c in COHORTS for draw in range(5)}
+    curve = rows(ROOT / 'source_data/fig2_strict_curve.csv')
+    if {(r['fold'], int(r['n_pairs'])) for r in curve} != expected_healthy:
+        gaps.append('Figure 2 strict CSV has incomplete fold/size units')
+    healthy = rows(ROOT / 'source_data/fig3_per_sample.csv')
+    if {r['fold'] for r in healthy} != {f'fold{n}' for n in range(5)}:
+        gaps.append('Figure 3 strict per-sample CSV has incomplete folds')
+    disease = rows(ROOT / 'source_data/fig4_strict_per_sample.csv')
+    if {(r['cohort'], r['draw']) for r in disease} != expected_disease or any(
+            r.get('design') != 'strict_exact5_donor_draw' for r in disease):
+        gaps.append('Figure 4 strict CSV has incomplete or mixed-design draws')
+    for filename, table in [('fig2_strict_curve.csv', curve), ('fig3_per_sample.csv', healthy),
+                            ('fig4_strict_per_sample.csv', disease)]:
+        if not table or any(not r.get('support_sha256') for r in table):
+            gaps.append(f'{filename} lacks source-bound support hashes')
+    for record in curve + healthy + disease:
+        source = record.get('summary')
+        source_hash = record.get('summary_sha256')
+        if source and source_hash and (not Path(source).is_file() or digest(Path(source)) != source_hash):
+            gaps.append(f'score summary hash mismatch: {source}')
+            break
+    for table, kind in ((curve, 'healthy'), (healthy, 'healthy'), (disease, 'disease')):
+        for record in table:
+            cohort = record.get('cohort', 'immicro')
+            unit = record.get('fold') if kind == 'healthy' else record.get('draw')
+            suffix = f'{unit}/n{record["n_pairs"]}' if table is curve else (
+                f'{unit}/n5' if kind == 'healthy' else unit)
+            support = ROOT / 'protocol/splits' / cohort / kind / suffix / 'support.json'
+            if not support.is_file() or document(support).get('sha256') != record.get('support_sha256'):
+                gaps.append(f'{cohort}/{kind}/{suffix}: source support mismatch')
+                break
+            summary = ROOT / 'scores' / cohort / kind / suffix / 'score/summary.json'
+            score_sha = record.get('score_sha256') or record.get('summary_sha256')
+            if not summary.is_file() or digest(summary) != score_sha:
+                gaps.append(f'{cohort}/{kind}/{suffix}: score summary hash mismatch')
+                break
+    rare_path = ROOT / 'reports/rare_provenance.json'
+    rare = document(rare_path) if rare_path.is_file() else {}
+    units = rare.get('units', [])
+    if (rare.get('schema') != 'pbisc.figure5.analysis.v1' or len(units) != 20 or
+            {(u.get('cohort'), u.get('unit')) for u in units} != expected_disease or
+            any(u.get('design') != 'strict5pair' or u.get('evidence_tier') != 'strict'
+                or not u.get('support_sha256') for u in units)):
+        gaps.append('Figure 5 needs all 20 strict rare-state receipts')
+    rare_table = rows(ROOT / 'source_data/rare_summary.csv')
+    if (not rare_table or {r.get('evidence_tier') for r in rare_table} != {'strict'} or
+            {(r['cohort'], r['unit']) for r in rare_table} != expected_disease):
+        gaps.append('Figure 5 rare-state CSV is absent, diagnostic or incomplete')
+    for cohort, unit in expected_disease:
+        subset = [r for r in rare_table if r.get('cohort') == cohort and r.get('unit') == unit]
+        if {r.get('arm') for r in subset} != {'raw', 'refcal', 'pairedcal', 'scsemi', 'lora'}:
+            gaps.append(f'Figure 5 strict arms incomplete: {cohort}/{unit}')
+            break
+    for unit in units:
+        support = ROOT / 'protocol/splits' / str(unit.get('cohort')) / 'disease' / str(unit.get('unit')) / 'support.json'
+        if not support.is_file() or document(support).get('sha256') != unit.get('support_sha256'):
+            gaps.append(f'Figure 5 strict support hash mismatch: {unit.get("cohort")}/{unit.get("unit")}')
+            break
+    if readiness.get('status') == 'complete':
+        runtime = ROOT / 'source_data/fig3_runtime.csv'
+        runtime_meta = ROOT / 'source_data/fig3_runtime.json'
+        visual = ROOT / 'source_data/fig3_visual_data.npz'
+        visual_meta = ROOT / 'source_data/fig3_visual_data.json'
+        if (not runtime.is_file() or not runtime_meta.is_file() or
+                document(runtime_meta).get('csv_sha256') != digest(runtime)):
+            gaps.append('Figure 3 runtime source/receipt hash mismatch')
+        if (not visual.is_file() or not visual_meta.is_file() or
+                document(visual_meta).get('npz_sha256') != digest(visual)):
+            gaps.append('Figure 3 visual source/receipt hash mismatch')
+        extras = ROOT / 'source_data/fig3_extras.csv'
+        if not extras.is_file() or not rows(extras):
+            gaps.append('Figure 3 realism extras CSV is missing')
+        for name in ('fig4_strict_contrast.csv', 'fig4_deconvolution.csv',
+                     'fig4_deconvolution_signal.csv', 'fig4_corrected_statistics.csv',
+                     'fig4_cross_draw_donor_ci.csv', 'fig4_donor_aware_signal.csv',
+                     'fig4_donor_aware_summary.csv', 'fig4_donor_aware_genes.csv',
+                     'fig4_donor_aware_cat.csv'):
+            path = ROOT / 'source_data' / name
+            if not path.is_file() or not rows(path):
+                gaps.append(f'Figure 4 required source table missing: {name}')
+        cross = ROOT / 'source_data/fig4_cross_draw_donor_ci.csv'
+        cross_receipt = ROOT / 'source_data/fig4_cross_draw_donor_ci.json'
+        if (not cross_receipt.is_file() or not cross.is_file() or
+                document(cross_receipt).get('csv_sha256') != digest(cross) or
+                {r.get('cohort') for r in rows(cross)} != set(COHORTS)):
+            gaps.append('Figure 4 five-draw donor-cluster CI source or receipt mismatch')
+        corrected = ROOT / 'source_data/fig4_donor_aware_signal.csv'
+        corrected_provenance = ROOT / 'source_data/fig4_donor_aware_provenance.json'
+        corrected_rows = rows(corrected) if corrected.is_file() else []
+        if (not corrected_provenance.is_file() or not corrected_rows or
+                {(r.get('cohort'), r.get('draw')) for r in corrected_rows} != expected_disease or
+                any(r.get('status') not in ('ok', 'not_estimable') for r in corrected_rows)):
+            gaps.append('Figure 4 corrected donor-aware disease signal is absent or incomplete')
+    for filename in FINAL_FIGURES:
+        if not (ROOT / 'figures' / filename).is_file():
+            gaps.append(f'missing strict figure: {filename}')
+    return gaps, readiness
+
+
+def numeric_summary(table: list[dict], keys: tuple[str, ...], metrics: tuple[str, ...]) -> str:
+    """Render observed means only; no unsupported ordering or P value."""
+    data: dict[tuple[str, ...], dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
+    for row in table:
+        group = tuple(row[k] for k in keys)
+        for metric in metrics:
+            try:
+                value = float(row[metric])
+            except (KeyError, ValueError, TypeError):
+                continue
+            if value == value and value not in (float('inf'), float('-inf')):
+                data[group][metric].append(value)
+    lines = []
+    for group, values in sorted(data.items()):
+        parts = [f'{key}={value}' for key, value in zip(keys, group)]
+        parts += [f'{metric}={sum(items)/len(items):.3f} (n={len(items)})'
+                  for metric, items in values.items() if items]
+        lines.append('; '.join(parts).replace('_', r'\_') + r'\par')
+    return '\n'.join(lines)
+
+
+def complete_results() -> None:
+    """Fill only numbers present in verified strict CSVs; leave no preview placeholders."""
+    additions = {
+        2: ('source_data/fig2_strict_curve.csv', ('n_pairs', 'arm'), ('precision', 'coverage')),
+        3: ('source_data/fig3_per_sample.csv', ('arm',), ('precision', 'coverage', 'comp_l1')),
+        4: ('source_data/fig4_strict_per_sample.csv', ('cohort', 'arm'), ('pb_r', 'comp_l1')),
+        5: ('source_data/rare_summary.csv', ('cohort', 'arm'), ('mae_donor_pp', 'generated_zero_donors')),
+    }
+    openers = {
+        2: (r'\subsection*{Pretraining design and strict paired-support curve}' '\n'
+            'The held-out native-pseudobulk precision and coverage ablations use the '
+            'common 1,006-gene rescore described in Methods. Architecture and gene-panel '
+            'families have different training detection floors. The nested ImMicro curve '
+            'uses five outer folds and $n=5,10,20,40$ distinct training donors per fold. '
+            'Historical rank and full-parameter five-fold results are reported separately.\n'),
+        3: (r'\subsection*{Healthy generation with exact five-pair support}' '\n'
+            'Each ImMicro outer fold uses one matched sample from each of five training '
+            'donors for LoRA, paired calibration and scSemiProfiler. The remaining donors '
+            'are evaluated on common observed cells, measured genes and frozen labels. '
+            'Figure~\\ref{fig:fig3} displays the strict quality measures and operational '
+            'time, which excludes population pretraining.\n'),
+        4: (r'\subsection*{Disease comparisons with exact five-pair support}' '\n'
+            'Each of four disease cohorts contributes five frozen draws. One earliest '
+            'identity-passed matched-stratum visit per selected donor trains all arms; '
+            'other visits of that donor are excluded. Donor-aware disease contrasts and '
+            'deconvolution are scored on the common held-out support. The old five-fold '
+            'analysis remains a separate historical sensitivity analysis.\n'),
+        5: (r'\subsection*{Rare states with paired support}' '\n'
+            'All four disease cohorts and five draws use the exact same five-pair supports '
+            'as Figure~\\ref{fig:fig4}. Zero-generated-state draws remain in every '
+            'aggregate, required-marker failures make a state ineligible, and repeated '
+            'visits are clustered by donor. The unmatched Beh\\c{c}et analysis is '
+            'descriptive and separate.\n'),
+    }
+    for number, (source, keys, metrics) in additions.items():
+        path = STAGE / 'sections' / f'results_fig{number}.tex'
+        text = openers[number]
+        text += ('\n\\textbf{Measured strict-support summary.} Values below are arithmetic means '
+                 'of the named source-data rows; $n$ counts rows, not independent donors. '
+                 'Donor-cluster uncertainty and formal comparisons require the separate '
+                 'statistics receipts.\\par\n')
+        text += numeric_summary(rows(ROOT / source), keys, metrics) + '\n'
+        if number == 3:
+            extras = []
+            for record in rows(ROOT / 'source_data/fig3_extras.csv'):
+                if record.get('table') == 'metrics.csv' and record.get('mode') == 'raw':
+                    extras.append({'arm': record.get('set', ''), **record})
+                elif (record.get('table') == 'en.csv' and record.get('cellset') == 'pc'
+                      and record.get('distance') == 'sq'):
+                    extras.append({'arm': record.get('set', ''), **record})
+            text += ('\n\\textbf{Realism and operational time.} C2ST AUC, MMD$^2$ '
+                     'and $E_N$ are computed from the strict extras; time is fine-tuning '
+                     'plus inference seconds, with pretraining excluded.\\par\n')
+            text += numeric_summary(extras, ('arm',), ('c2st_rf_auc', 'mmd2_sum', 'en')) + '\n'
+            text += numeric_summary(rows(ROOT / 'source_data/fig3_runtime.csv'),
+                                    ('arm',), ('operational_seconds',)) + '\n'
+        if number == 4:
+            donor_aware = [r for r in rows(ROOT / 'source_data/fig4_donor_aware_signal.csv')
+                           if r.get('status') == 'ok']
+            text += ('\n\\textbf{Primary donor-aware disease signal.} Equal-patient '
+                     'condition contrasts, with repeated visits collapsed by donor and '
+                     'condition, are reported by cohort, arm, cell type and draw. '
+                     'A missing population is marked not estimable and contributes no '
+                     'fabricated zero. The values below summarize estimable rows; '
+                     'patient-cluster intervals are in the accompanying source tables.\\par\n')
+            text += numeric_summary(donor_aware, ('cohort', 'arm'),
+                                    ('pearson_r', 'partial_r', 'cat50', 'limma_top50')) + '\n'
+            contrast = [r for r in rows(ROOT / 'source_data/fig4_strict_contrast.csv')
+                        if r.get('table') == 'headline.csv']
+            text += ('\n\\textbf{Historical contrast sensitivity.} The legacy per-sample '
+                     'logFC, CAT and limma headline values below retain their original '
+                     'independent-sample definition. They are separate from corrected '
+                     'donor-aware disease signal.\\par\n')
+            text += numeric_summary(contrast, ('cohort', 'arm'),
+                                    ('partial_r', 'cat50', 'limma_top50')) + '\n'
+            text += ('\n\\textbf{Cross-draw uncertainty.} Donor-cluster confidence intervals '
+                     'over all five verified draws, with repeated visits and draw membership '
+                     'kept together, are supplied in '
+                     '\\texttt{fig4\\_cross\\_draw\\_donor\\_ci.csv}.\\par\n')
+            text += ('\n\\textbf{Same-support deconvolution.} Deconvolution '
+                     'provides fractions and supported cell-type expression, not '
+                     'generated-cell realism scores.\\par\n')
+            text += numeric_summary(rows(ROOT / 'source_data/fig4_deconvolution.csv'),
+                                    ('cohort', 'arm'), ('composition_l1',)) + '\n'
+        path.write_text(text)
+    path = STAGE / 'sections/discussion.tex'
+    path.write_text('\\section*{Discussion}\n'
+                    'The strict-support numerical summaries in Figs~2--5 report the completed '
+                    'five-pair design. They should be interpreted with their donor-cluster '
+                    'uncertainty and source tables; row counts are not biological replicates. '
+                    'Historical five-fold and unmatched Beh\\c{c}et analyses remain separate. '
+                    'Figure~\\ref{fig:fig6} awaits the user-prepared bulk-only reproduction data.\n')
+
+
+def copy_source_files() -> dict[str, str]:
+    before = {}
+    for rel in tracked_sources():
+        src, dst = CANON / rel, STAGE / rel
+        if not src.is_file():
+            raise ValueError(f'tracked source missing: {src}')
+        before[str(rel)] = digest(src)
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src, dst)
+    return before
+
+
+def edit_method_model() -> None:
+    path = STAGE / 'sections/methods_model.tex'
+    body = path.read_text().split('\\subsection*{SLE benchmark and frozen cell-type annotator}')[0]
+    body = body.replace('Fig.~\\ref{fig:fig1}b', 'Fig.~\\ref{fig:fig1}')
+    body = body.replace('Fig.~\\ref{fig:fig1}a', 'Fig.~\\ref{fig:fig1}')
+    body = body.replace('Fig.~\\ref{fig:fig1}c', 'Fig.~\\ref{fig:fig1}')
+    body = body.replace('Fig.~\\ref{fig:fig1}d', 'Fig.~\\ref{fig:fig1}')
+    body = body.replace('Fig.~\\ref{fig:fig1}f', 'Fig.~\\ref{fig:fig2}')
+    body = re.sub(r'It produced every generated cell set in this study except the threshold-read-out sets.*?Unless stated otherwise',
+                  'The pretraining design rescoring in Fig.~\\\\ref{fig:fig2} uses saved epoch-16 Bernoulli outputs. Unless stated otherwise',
+                  body, flags=re.S)
+    body += '\n\\subsection*{Held-out pretraining design rescore}\n'
+    body += ('Saved architecture and gene-panel outputs for the 42 held-out SLE donors were rescored '
+             'separately. On the common 1,006-gene axis, each donor contributed 100 real reference cells, '
+             '100 disjoint real query cells and 100 generated cells per arm. One fixed Poisson read-out, '
+             'a real-reference 50-component PCA and $k=10$ local neighbourhoods defined precision and '
+             'coverage. The architecture and panel families had different training detection floors and '
+             'are not a factorial comparison. One saved generation seed per arm makes these descriptive scores.\n')
+    path.write_text(body)
+
+
+def overlay(final: bool) -> list[str]:
+    changed = []
+    for src in sorted((EDITS / 'sections').glob('*.tex')):
+        dst = STAGE / 'sections' / src.name
+        shutil.copy2(src, dst)
+        changed.append(str(dst.relative_to(STAGE)))
+    edit_method_model()
+    changed.append('sections/methods_model.tex')
+    main = STAGE / 'main.tex'
+    content = main.read_text()
+    content = content.replace('% Overleaf main document.', '% RESTRUCTURING DRAFT: strict Figures 3--5 remain pending.\n% Overleaf main document.', 1)
+    content = content.replace('% Figures with their legends, each on its own page(s). Panels are the deck\'s vector graphics, placed as-is;\n% the 180 mm journal layout is still to be drawn.',
+                              '% Figure 1--5 restructuring draft; strict missing panels are explicitly labelled.')
+    if final:
+        content = content.replace('% RESTRUCTURING DRAFT: strict Figures 3--5 remain pending.\n', '')
+    else:
+        content = content.replace('\\maketitle',
+            '\\maketitle\n\\noindent\\fcolorbox{red}{white}{\\parbox{0.92\\textwidth}{'
+            '\\textbf{RESTRUCTURING DRAFT.} Strict five-pair results for Figs 2--5 '
+            'are incomplete. The approved title, abstract and Introduction retain their '
+            'original wording and must be rereviewed against final strict results.}}\\par\\medskip', 1)
+    main.write_text(content)
+    changed.append('main.tex')
+    supp = STAGE / 'supplementary.tex'
+    supp_text = supp.read_text()
+    supp_text = supp_text.replace('\\begin{document}',
+        '\\begin{document}\n\\noindent\\textcolor{red}{[HISTORICAL SUPPLEMENTARY DRAFT: '
+        'legacy analyses have not been reconciled with exact-five-pair support.]}\\par\\medskip', 1)
+    supp.write_text(supp_text)
+    changed.append('supplementary.tex')
+    figures = dict(FIGURES)
+    if final:
+        complete_results()
+        figures.update(FINAL_FIGURES)
+        strict_figures = {
+            'fig3': ('Healthy exact five-pair OOF', 'fig3_healthy_strict_oof.pdf'),
+            'fig4': ('Disease exact five-pair draws', 'fig4_disease_strict_draws.pdf'),
+            'fig5': ('Paired rare states under exact five-pair support', 'fig5_rare_states_strict.pdf'),
+        }
+        for name, (title, filename) in strict_figures.items():
+            p = STAGE / 'sections' / f'{name}.tex'
+            panels = f'\\figpanelh{{}}{{figures/strict_20261012/{filename}}}{{0.77}}\n'
+            if name == 'fig3':
+                panels += ('\\figpanelh{}{figures/strict_20261012/fig3_realism_metrics.pdf}{0.38}\n')
+                panels += ('\\figpanelh{}{figures/strict_20261012/fig3_canonical_marker_dotplot.pdf}{0.42}\n')
+                for extra in ('umap_by_celltype','composition_fractions','runtime_components'):
+                    panels += f'\\figpanelh{{}}{{figures/strict_20261012/fig3_{extra}.pdf}}{{0.62}}\n'
+            if name == 'fig4':
+                panels += ('\\figpanelh{}{figures/strict_20261012/fig4_disease_signal_strict.pdf}{0.48}\n'
+                           '\\figpanelh{}{figures/strict_20261012/fig4_deconvolution_strict.pdf}{0.42}\n'
+                           '\\figpanelh{}{figures/strict_20261012/fig4_deconvolution_expression_strict.pdf}{0.48}\n')
+                panels += ('\\figpanelh{}{figures/strict_20261012/fig4_historical_5fold_separate.pdf}{0.38}\n')
+                for extra in ('scatter','heatmap','cat'):
+                    panels += f'\\figpanelh{{}}{{figures/strict_20261012/fig4_disease_signal_{extra}.pdf}}{{0.60}}\n'
+            if name == 'fig5':
+                for extra in ('rare_visuals','all_states','behcet_rules'):
+                    panels += f'\\figpanelh{{}}{{figures/strict_20261012/fig5_{extra}_strict.pdf}}{{0.72}}\n'
+            p.write_text(f'\\mainfigure{{fig:{name}}}{{{title}}}\n' + panels +
+                         '\\figlegend{Strict-support results and source-data tables are '
+                         'reported in the corresponding Results section. Figure 4 historical '
+                         'five-fold values appear in a separate labelled panel.}\n')
+    for source, target in figures.items():
+        src = ROOT / 'figures' / source
+        if not src.is_file():
+            raise ValueError(f'missing figure: {src}')
+        dst = STAGE / 'figures/strict_20261012' / target
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src, dst)
+        changed.append(str(dst.relative_to(STAGE)))
+    evidence = ('source_data/fig1_corpus_aggregates.json',
+                'source_data/ablation_pretrain_pc.csv',
+                'source_data/ablation_pretrain_pc_receipt.json',
+                'source_data/fig2_historical_rank_full.csv',
+                'source_data/fig4_historical_5fold.csv',
+                'reports/figure1_provenance.json',
+                'reports/figures234_readiness.json',
+                'reports/rare_provenance.json')
+    if final:
+        evidence += ('source_data/fig2_strict_curve.csv',
+                     'source_data/fig3_per_sample.csv',
+                     'source_data/fig3_extras.csv',
+                     'source_data/fig3_runtime.csv',
+                     'source_data/fig3_runtime.json',
+                     'source_data/fig3_visual_data.json',
+                     'source_data/fig4_strict_per_sample.csv',
+                     'source_data/fig4_corrected_statistics.csv',
+                     'source_data/fig4_cross_draw_donor_ci.csv',
+                     'source_data/fig4_cross_draw_donor_ci.json',
+                     'source_data/fig4_donor_aware_signal.csv',
+                     'source_data/fig4_donor_aware_summary.csv',
+                     'source_data/fig4_donor_aware_genes.csv',
+                     'source_data/fig4_donor_aware_cat.csv',
+                     'source_data/fig4_donor_aware_provenance.json',
+                     'source_data/fig4_strict_contrast.csv',
+                     'source_data/fig4_deconvolution.csv',
+                     'source_data/fig4_deconvolution_signal.csv',
+                     'source_data/rare_summary.csv',
+                     'source_data/rare_ineligible_states.csv',
+                     'source_data/rare_behcet_descriptive.csv')
+    for rel in evidence:
+        src = ROOT / rel
+        if not src.is_file():
+            raise ValueError(f'missing source data: {src}')
+        dst = STAGE / 'strict_20261012' / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src, dst)
+        changed.append(str(dst.relative_to(STAGE)))
+    changed.extend(['sections/fig1.tex', 'sections/fig2.tex', 'sections/fig3.tex',
+                    'sections/fig4.tex', 'sections/fig5.tex'])
+    return sorted(set(changed))
+
+
+def verify_unchanged_frontmatter(original: dict[str, str]) -> None:
+    for name in ('sections/abstract.tex', 'sections/introduction.tex', 'authors.tex'):
+        if digest(STAGE / name) != original[name]:
+            raise ValueError(f'user-approved frontmatter changed: {name}')
+    canonical_main = (CANON / 'main.tex').read_text()
+    staged_main = (STAGE / 'main.tex').read_text()
+    for pattern in (r'\\title\{[^\n]+', r'\\abstract\{[^\n]+'):
+        if re.search(pattern, canonical_main).group() != re.search(pattern, staged_main).group():
+            raise ValueError(f'user-approved title or abstract command changed: {pattern}')
+
+
+def allowed_frontmatter_refresh(previous: dict[str, str], current: dict[str, str],
+                                *, old_main: str | None = None, new_main: str | None = None) -> dict:
+    """Permit only new approved Title, Abstract and Introduction source text."""
+    changed = {name: {'previous_sha256': old, 'current_sha256': current.get(name)}
+               for name, old in previous.items() if current.get(name) != old}
+    allowed = {'main.tex', 'sections/abstract.tex', 'sections/introduction.tex'}
+    extra = set(changed) - allowed
+    if extra:
+        raise ValueError(f'canonical source changed outside approved frontmatter: {sorted(extra)}')
+    if 'main.tex' in changed:
+        if old_main is None or new_main is None:
+            raise ValueError('main.tex changed beyond approved title/abstract commands')
+        pattern = r'\\(?:title|abstract)\{[^\n]*\}'
+        if re.sub(pattern, r'\\frontmatter{APPROVED}', old_main) != re.sub(
+                pattern, r'\\frontmatter{APPROVED}', new_main):
+            raise ValueError('main.tex changed beyond approved title/abstract commands')
+    return changed
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    mode = p.add_mutually_exclusive_group(required=True)
+    mode.add_argument('--preview', action='store_true')
+    mode.add_argument('--require-complete', action='store_true')
+    args = p.parse_args()
+    if subprocess.check_output(['git', '-C', str(CANON), 'status', '--porcelain']).strip():
+        raise SystemExit('canonical manuscript is not clean; refusing to assemble')
+    checked_provenance(ROOT / 'reports/figure1_provenance.json', 'Figure 1')
+    pretrain = checked_provenance(ROOT / 'source_data/ablation_pretrain_pc_receipt.json', 'Figure 2 P/C')
+    recipe = pretrain.get('recipe', {})
+    if (pretrain.get('schema') != 'pbisc.fig2.pretrain_pc.v1' or
+            recipe.get('n_pcs') != 50 or recipe.get('local_k') != 10 or
+            pretrain.get('gene_axis', {}).get('n') != 1006 or
+            {r['family'] for r in rows(ROOT / 'source_data/ablation_pretrain_pc.csv')} !=
+            {'architecture_floor1pct', 'panel_floor0.1pct'}):
+        raise SystemExit('Figure 2 measured P/C receipt or source table differs from the frozen rescore')
+    gaps, readiness = strict_gate()
+    if args.require_complete and gaps:
+        raise SystemExit('final assembly refused:\n- ' + '\n- '.join(sorted(set(gaps))))
+    previous = STAGE / 'integration_manifest.json'
+    refreshed = {}
+    if previous.is_file() and args.require_complete:
+        prior = document(previous)
+        old = prior.get('canonical_source_sha256', {})
+        current = {rel: digest(CANON / rel) if (CANON / rel).is_file() else None for rel in old}
+        old_main = None
+        if current.get('main.tex') != old.get('main.tex'):
+            old_head = prior.get('canonical_head')
+            if not old_head:
+                raise SystemExit('review preview has no canonical head for frontmatter comparison')
+            old_main = subprocess.check_output(['git', '-C', str(CANON), 'show',
+                                                f'{old_head}:main.tex'], text=True)
+        try:
+            refreshed = allowed_frontmatter_refresh(old, current, old_main=old_main,
+                                                    new_main=(CANON / 'main.tex').read_text())
+        except ValueError as exc:
+            raise SystemExit(str(exc)) from exc
+    originals = copy_source_files()
+    changed = overlay(args.require_complete)
+    verify_unchanged_frontmatter(originals)
+    # Keep the original claims available for review without placing them in Results.
+    legacy = STAGE / 'editorial/legacy_results'
+    legacy.mkdir(parents=True, exist_ok=True)
+    for name in ('results_fig1', 'results_fig2', 'results_fig3', 'results_fig4',
+                 'results_fig5', 'results_fig6', 'methods_paired', 'methods_eval', 'discussion'):
+        src = CANON / 'sections' / f'{name}.tex'
+        shutil.copy2(src, legacy / src.name)
+        changed.append(str((legacy / src.name).relative_to(STAGE)))
+    manifest = {
+        'schema': 'pbisc.paper.manuscript-integration.v1',
+        'mode': 'complete' if args.require_complete else 'restructuring_preview',
+        'canonical_root': str(CANON), 'stage_root': str(STAGE),
+        'canonical_head': subprocess.check_output(['git', '-C', str(CANON), 'rev-parse', 'HEAD'], text=True).strip(),
+        'canonical_source_sha256': originals,
+        'approved_frontmatter_refresh': refreshed,
+        'staged_changes': {rel: {'sha256': digest(STAGE / rel),
+                                 'canonical_sha256': originals.get(rel)} for rel in changed},
+        'figure_source_sha256': {name: digest(ROOT / 'figures' / name) for name in
+                                 (FIGURES | (FINAL_FIGURES if args.require_complete else {}))},
+        'readiness': readiness,
+        'gaps': gaps,
+        'figure6': 'waiting_user_prepared_data; unchanged placeholder',
+        'git_push': False, 'overleaf_sync': False,
+    }
+    previous.write_text(json.dumps(manifest, indent=2) + '\n')
+    print(json.dumps({'mode': manifest['mode'], 'staged_changed_files': len(changed),
+                      'gaps': gaps, 'manifest': str(previous)}, indent=2))
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Deterministically draw the 180 mm PBISC-Diffusion overview from frozen tables."""
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.patches import FancyArrowPatch, FancyBboxPatch, Rectangle
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MANUSCRIPT = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+CORPUS = MANUSCRIPT / "source_data/corpus"
+SOURCES = [
+    CORPUS / "corpus_summary.json",
+    CORPUS / "corpus_assay_condition.csv",
+    CORPUS / "corpus_celltypes.csv",
+    CORPUS / "corpus_datasets.csv",
+    CORPUS / "README.md",
+    MANUSCRIPT / "sections/methods_model.tex",
+    MANUSCRIPT / "sections/methods_paired.tex",
+    ROOT / "protocol/PROTOCOL.json",
+]
+INK = "#26384a"
+MUTED = "#526478"
+FAINT = "#d9e1e8"
+BG = "#ffffff"
+BLUE = "#0072B2"
+TEAL = "#009E73"
+ORANGE = "#E69F00"
+VERMILION = "#D55E00"
+PURPLE = "#765A9A"
+GREY = "#8995a3"
+LIGHT_BLUE = "#eaf4fa"
+LIGHT_TEAL = "#eaf6f2"
+LIGHT_ORANGE = "#fbf3e0"
+LIGHT_PURPLE = "#f2eef8"
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for block in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def read_data() -> dict:
+    s = json.loads((CORPUS / "corpus_summary.json").read_text())
+    datasets = list(csv.DictReader((CORPUS / "corpus_datasets.csv").open()))
+    assay_condition = list(csv.DictReader((CORPUS / "corpus_assay_condition.csv").open()))
+    celltypes = list(csv.DictReader((CORPUS / "corpus_celltypes.csv").open()))
+    assert len(datasets) == s["datasets"] == 22
+    assert sum(int(r["n_cells"]) for r in datasets) == s["cells"] == 41_395_184
+    assert sum(int(r["n_cells"]) for r in assay_condition) == s["cells"]
+    assert sum(int(r["n_cells"]) for r in celltypes) == s["cells"]
+    assert sum(s["split_cells"].values()) == s["cells"]
+    assert s["split_cells"]["train"] == 33_141_380
+    assert s["donors"] == 3199 and s["samples"] == 6507
+    assert abs(s["family_cells"]["Healthy"] / s["cells"] - 0.8851) < .001
+    assert abs(s["handling_cells"]["in vitro"] / s["cells"] - 0.2361) < .001
+    # Healthy and in-vitro are overlapping attributes; preserve their separate denominators.
+    by_assay = {
+        "10x": s["platform_cells"]["10x"],
+        "Parse": s["platform_cells"]["Parse"],
+        "ScaleBio + Seq-Well": s["platform_cells"]["ScaleBio"] + s["platform_cells"]["Seq-Well"],
+    }
+    by_condition = {
+        "Healthy": s["family_cells"]["Healthy"],
+        "Autoimmune": s["family_cells"]["Autoimmune"],
+        "Infection": s["family_cells"]["Infection"],
+        "Other": s["family_cells"]["Hematologic"] + s["family_cells"]["Drug reaction"],
+    }
+    by_celltype = {
+        "T cell": s["celltype_l1_cells"]["T cell"],
+        "Monocyte": s["celltype_l1_cells"]["Monocyte"],
+        "B cell": s["celltype_l1_cells"]["B cell"],
+        "NK cell": s["celltype_l1_cells"]["NK cell"],
+        "Other / unlabeled": s["cells"] - sum(s["celltype_l1_cells"][x] for x in ("T cell", "Monocyte", "B cell", "NK cell")),
+    }
+    for group in (by_assay, by_condition, by_celltype):
+        assert sum(group.values()) == s["cells"]
+    return {"summary": s, "assay": by_assay, "condition": by_condition, "cell_type": by_celltype}
+
+
+def box(ax, x, y, w, h, face, edge=FAINT, radius=.011, lw=.7):
+    p = FancyBboxPatch((x, y), w, h, boxstyle=f"round,pad=0,rounding_size={radius}",
+                       facecolor=face, edgecolor=edge, linewidth=lw)
+    ax.add_patch(p)
+    return p
+
+
+def tx(ax, x, y, value, size=7.4, color=INK, weight="normal", ha="left", va="center", **kw):
+    return ax.text(x, y, value, fontsize=size, color=color, weight=weight,
+                   ha=ha, va=va, family="DejaVu Sans", **kw)
+
+
+def arrow(ax, x0, y0, x1, y1, color=MUTED, lw=1.25, ls="solid", scale=9):
+    ax.add_patch(FancyArrowPatch((x0, y0), (x1, y1), arrowstyle="-|>",
+                  mutation_scale=scale, linewidth=lw, linestyle=ls, color=color))
+
+
+def panel(ax, letter, title, y):
+    tx(ax, .025, y, letter, 12.2, INK, "bold", va="top")
+    tx(ax, .073, y-.002, title, 9.6, INK, "bold", va="top")
+
+
+def stacked(ax, y, label, items, colors, total):
+    x0, w = .205, .739
+    tx(ax, .077, y+.012, label, 7.6, INK, "bold")
+    x = x0
+    for (name, value), color in zip(items.items(), colors):
+        dx = w * value / total
+        ax.add_patch(Rectangle((x, y), dx, .022, facecolor=color, edgecolor="white", linewidth=.6))
+        if dx >= .057:
+            tx(ax, x + dx/2, y+.011, f"{100*value/total:.1f}%", 6.6,
+               "white" if color not in (ORANGE, GREY) else INK, "bold", ha="center")
+        x += dx
+    # Every category is in an editable legend below each bar.
+    legend = "   ·   ".join(f"{k} {100*v/total:.1f}%" for k,v in items.items())
+    tx(ax, x0, y-.012, legend, 6.55, MUTED, va="top")
+
+
+def draw(data):
+    plt.rcParams.update({"svg.fonttype": "none", "pdf.fonttype": 42,
+                         "font.family": "DejaVu Sans", "savefig.facecolor": "white"})
+    fig = plt.figure(figsize=(7.087, 8.55), facecolor=BG)
+    ax = fig.add_axes([0,0,1,1]); ax.set_xlim(0,1); ax.set_ylim(0,1); ax.axis("off")
+    ax.add_patch(Rectangle((0,0),1,1,facecolor=BG,edgecolor="none"))
+    tx(ax, .025, .988, "PBISC-Diffusion", 14, INK, "bold", va="top")
+    tx(ax, .975, .987, "from population pretraining to one measured bulk", 8.2, MUTED, ha="right", va="top")
+    ax.plot([.025,.975],[.962,.962],color=FAINT,lw=.9)
+
+    # a. One main adaptation path; the external-reference route is explicitly separate.
+    panel(ax, "a", "Pretrain once  →  adapt on five independent donors  →  infer a new sample", .946)
+    y,h=.852,.063
+    box(ax,.075,y,.249,h,LIGHT_BLUE,BLUE)
+    tx(ax,.092,y+.041,"PBMC pseudobulk pretraining",8.1,BLUE,"bold")
+    tx(ax,.092,y+.018,"33.1 M train cells · 6,000 genes",7.15,INK)
+    arrow(ax,.328,y+.031,.380,y+.031,BLUE)
+    box(ax,.383,y,.251,h,LIGHT_ORANGE,ORANGE)
+    tx(ax,.400,y+.041,"LoRA r = 16 · 3,000 steps",8.1,VERMILION,"bold")
+    tx(ax,.400,y+.018,"exactly 5 donors × 1 pair each",7.15,INK)
+    arrow(ax,.638,y+.031,.691,y+.031,VERMILION)
+    box(ax,.695,y,.258,h,LIGHT_TEAL,TEAL)
+    tx(ax,.712,y+.041,"New measured real bulk",8.1,TEAL,"bold")
+    tx(ax,.712,y+.018,"one condition → synthetic cells",7.15,INK)
+    ax.plot([.160,.160,.280],[.846,.826,.826],color=GREY,lw=1,ls=(0,(2.2,2.2)))
+    ax.plot([.665,.744],[.826,.826],color=GREY,lw=1,ls=(0,(2.2,2.2)))
+    arrow(ax,.744,.826,.744,.850,GREY,.95,"dotted",7)
+    tx(ax,.455,.825,"Alternative: external AIFI reference calibration",7.0,MUTED,ha="center")
+    tx(ax,.086,.805,"Reference branch uses external cells; no calibration is part of the main LoRA path.",7.0,MUTED)
+    ax.plot([.025,.975],[.787,.787],color=FAINT,lw=.7)
+
+    # b. State and conditioner, with measurable/unmeasured semantics.
+    panel(ax,"b","Gene-space joint diffusion with a measured-gene mask",.775)
+    box(ax,.075,.686,.238,.060,LIGHT_BLUE,BLUE)
+    tx(ax,.092,.726,"Noisy cell state  [2 × 6,000]",7.7,BLUE,"bold")
+    tx(ax,.092,.704,"value + detection support",7.3,INK)
+    arrow(ax,.316,.716,.371,.716,BLUE)
+    box(ax,.374,.680,.251,.073,"#f2f5f8",MUTED)
+    tx(ax,.499,.729,"7-block denoiser",8.15,INK,"bold",ha="center")
+    tx(ax,.499,.707,"time + self-conditioning",7.2,MUTED,ha="center")
+    tx(ax,.499,.691,"measured genes enter loss",6.9,MUTED,ha="center")
+    arrow(ax,.629,.716,.687,.716,TEAL)
+    box(ax,.690,.686,.265,.060,LIGHT_TEAL,TEAL)
+    tx(ax,.707,.726,"Predicted clean cell",7.8,TEAL,"bold")
+    tx(ax,.707,.704,"value + support logits",7.3,INK)
+    box(ax,.077,.624,.876,.052,LIGHT_PURPLE,PURPLE)
+    tx(ax,.092,.651,"Bulk condition",7.6,PURPLE,"bold")
+    tx(ax,.226,.651,"6,000 expression + 6 scalars + 6,000 input measurement + 6,000 output availability",6.95,INK)
+    tx(ax,.226,.638,"18,006 inputs  →  512-dimensional context; assay-missing genes are excluded, not treated as zeros",6.9,MUTED)
+    arrow(ax,.498,.676,.498,.679,PURPLE,1.0,scale=7)
+    ax.plot([.025,.975],[.610,.610],color=FAINT,lw=.7)
+
+    # c. Parameter meanings have two distinct routes.
+    panel(ax,"c","Constructing the condition: pseudobulk and real bulk",.598)
+    box(ax,.075,.524,.425,.049,LIGHT_BLUE,BLUE)
+    tx(ax,.090,.552,"Pretraining pseudobulk",7.8,BLUE,"bold")
+    tx(ax,.090,.535,"K_cond = member cells · L = Σ raw UMIs · ρ = L/K_cond",6.95,INK)
+    box(ax,.515,.524,.440,.049,LIGHT_ORANGE,ORANGE)
+    tx(ax,.530,.552,"Real-bulk adaptation and inference",7.8,VERMILION,"bold")
+    tx(ax,.530,.535,"K_cond = 1,000 supplied · ρ = 3,869.603 train anchor",6.95,INK)
+    tx(ax,.085,.504,"ρ is the per-cell depth used to scale the bulk; it is derived in pretraining and fixed for real bulk.",7.05,MUTED)
+    ax.plot([.025,.975],[.490,.490],color=FAINT,lw=.7)
+
+    # d. Shared conditioning, independent stochastic cells; no hidden compositional constraint.
+    panel(ax,"d","Independent cell draws from the same measured bulk",.478)
+    box(ax,.075,.401,.183,.047,LIGHT_TEAL,TEAL)
+    tx(ax,.166,.432,"One condition",7.7,TEAL,"bold",ha="center")
+    tx(ax,.166,.413,"K_cond = 1,000",7.1,INK,ha="center")
+    arrow(ax,.261,.424,.309,.424,TEAL)
+    box(ax,.312,.398,.318,.053,"#f2f5f8",MUTED)
+    tx(ax,.471,.433,"50 DDIM steps · shared denoiser",7.75,INK,"bold",ha="center")
+    tx(ax,.471,.412,"independent initial noise for each cell",7.05,MUTED,ha="center")
+    arrow(ax,.635,.424,.679,.424,TEAL)
+    box(ax,.683,.401,.271,.047,LIGHT_TEAL,TEAL)
+    tx(ax,.819,.432,"N_gen = 1,500 cells",7.75,TEAL,"bold",ha="center")
+    tx(ax,.819,.413,"batchable · no autoregression",7.0,INK,ha="center")
+    tx(ax,.085,.379,"Each cell receives its own noise and support draw; cell sums are evaluated against bulk, never constrained to equal it.",7.05,MUTED)
+    ax.plot([.025,.975],[.360,.360],color=FAINT,lw=.7)
+
+    # e. Corpus is a genuine data panel, values generated from manuscript source tables.
+    panel(ax,"e","Pretraining corpus: assay, condition and cell-type coverage",.347)
+    cards=[("41,395,184","all cells"),("33,141,380","train cells"),("22","datasets"),("3,199","donors"),("6,507","samples")]
+    for i,(number,label) in enumerate(cards):
+        x=.076+i*.177
+        box(ax,x,.283,.167,.043,"#f4f7f9",FAINT,radius=.006)
+        tx(ax,x+.0835,.308,number,8.2,INK,"bold",ha="center")
+        tx(ax,x+.0835,.291,label,6.7,MUTED,ha="center")
+    total=data["summary"]["cells"]
+    stacked(ax,.244,"Assay",data["assay"],[BLUE,TEAL,GREY],total)
+    stacked(ax,.183,"Condition",data["condition"],[TEAL,VERMILION,ORANGE,GREY],total)
+    stacked(ax,.122,"Cell type",data["cell_type"],[BLUE,VERMILION,PURPLE,TEAL,GREY],total)
+    healthy=100*data["summary"]["family_cells"]["Healthy"]/total
+    vitro=100*data["summary"]["handling_cells"]["in vitro"]/total
+    tx(ax,.077,.057,f"{healthy:.1f}% healthy  ·  {vitro:.1f}% in vitro",7.7,INK,"bold")
+    tx(ax,.077,.038,"Shares are of all cells; healthy and in vitro overlap. Labels describe the corpus, not model inputs.",6.9,MUTED)
+    ax.plot([.025,.975],[.026,.026],color=FAINT,lw=.8)
+    tx(ax,.025,.015,"PBISC-Diffusion  |  180 mm figure width  |  source data: manuscript corpus tables",6.1,MUTED,va="center")
+    return fig
+
+
+def main():
+    data=read_data()
+    (ROOT/"figures").mkdir(exist_ok=True)
+    (ROOT/"source_data").mkdir(exist_ok=True)
+    (ROOT/"reports").mkdir(exist_ok=True)
+    src=ROOT/"source_data/fig1_corpus_aggregates.json"
+    src.write_text(json.dumps({
+        "schema":"pbisc.figure1.corpus.v1",
+        "denominator":"all 41,395,184 corpus cells; proportions are cell shares, not donor shares",
+        "condition_handling_overlap":"healthy and in vitro are overlapping attributes",
+        "aggregates":{k:v for k,v in data.items() if k != "summary"},
+        "totals":{k:data["summary"][k] for k in ("cells","datasets","samples","donors","split_cells","family_cells","handling_cells")},
+        "sources":[{"path":str(p),"sha256":sha(p)} for p in SOURCES],
+    },indent=2)+"\n")
+    fig=draw(data)
+    base=ROOT/"figures/fig1_overview"
+    for ext, kw in [("svg",{}),("pdf",{}),("png",{"dpi":300})]:
+        fig.savefig(base.with_suffix("."+ext), facecolor="white", **kw)
+    plt.close(fig)
+    provenance={
+        "schema":"pbisc.figure1.provenance.v1",
+        "figure_width_mm":180,
+        "scope":"Figure 1 overview; schematic method panels and manuscript-derived corpus aggregates",
+        "design":"deterministic Matplotlib vector authoring; SVG retains editable text",
+        "sources":[{"path":str(p),"sha256":sha(p)} for p in SOURCES],
+        "outputs":[{"path":str(p),"sha256":sha(p),"bytes":p.stat().st_size} for p in
+                   [base.with_suffix(".svg"),base.with_suffix(".pdf"),base.with_suffix(".png"),src]],
+        "semantics":{
+            "pseudobulk_K_cond":"number of source recipe cells; L=sum of raw UMIs; rho=L/K_cond",
+            "real_bulk_K_cond":1000,
+            "real_bulk_rho_counts_per_cell":3869.603120208939,
+            "N_gen":1500,
+            "independence":"N_gen independent noise and support draws; no autoregression or sum constraint",
+            "main_adaptation":"LoRA rank 16, 3000 steps, exactly one pair from each of five independent donors; no calibration",
+            "alternative":"external AIFI reference calibration, shown schematically without performance claim",
+            "condition_dimensions": {"expression":6000,"scalars":6,"input_measurement":6000,"output_availability":6000,"total":18006,"context":512},
+        },
+    }
+    (ROOT/"reports/figure1_provenance.json").write_text(json.dumps(provenance,indent=2)+"\n")
+    print(json.dumps({"figure":str(base.with_suffix('.png')),"source_data":str(src),"outputs":provenance["outputs"]},indent=2))
+
+
+if __name__=="__main__":
+    main()