exp000 baseline wall + substrate (runner-2 line opened)

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+exp000_baselines/base_lune_cond_0.png filter=lfs diff=lfs merge=lfs -text
+exp000_baselines/json_ckpt2500_cond_0.png filter=lfs diff=lfs merge=lfs -text
+exp000_baselines/json_ckpt2500_shuffled_0.png filter=lfs diff=lfs merge=lfs -text
+exp000_baselines/json_vit_cond_0.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,74 @@
+---
+license: mit
+tags:
+- diffusion
+- adapters
+- aleph
+- geolip
+---
+
+# geolip-aleph-diffusion
+
+Testable **aleph adapters** for the geolip diffusion variants — the certified
+components of the geolip-aleph-qwen text line (frozen-trunk relay adapters with
+closed-form aleph addressing, zero-init out weight+bias, near-zero gates,
+bit-exact toggle contract) ported to diffusion trunks. Runner-2 line of the
+geolip program.
+
+## Substrates
+
+| variant | trunk | trainer path |
+|---|---|---|
+| SD15-Lune rectified flow | `AbstractPhil/sd15-flow-lune-json-prompt` ckpt-2500 (+ base lune, json-vit) | custom beds (this repo, `substrate/`) |
+| Anima / Cosmos-Predict2 2B DiT | `circlestone-labs/Anima` (NC weights — all derived checkpoints NC) | `AbstractEyes/diffusion-pipe` branch `feat/aleph-adapter` |
+| SDXL | `AbstractPhil/geolip-sdxl-aleph` phase-1 ckpts | read-only capacity battery first |
+
+Sampler of record (Lune family): rectified flow, `v = noise − x0`, Euler on the
+**SHIFT=2.5-warped** sigma grid `σ = 2.5u/(1+1.5u)`, `VAE_SCALE 0.18215`. Text
+conditioning is the trainer's 225-token 3-chunk CLIP encoding (`encode_clip_225`,
+227 positions) — never a bare 77-token encode.
+
+## Standing rules of the line
+
+- Adapter dtype **matches the trunk dtype** (fp32 adapters on a low-precision
+  trunk inject fp32 noise; judged gauges still run fp32).
+- Pure Adam, weight-decay 0 on adapter paths — never AdamW.
+- No comparative selectors (argmax/softmax routing/VQ) anywhere near the aleph;
+  the addresser is the closed-form sinh/cosh read.
+- All-adapters-off ≡ frozen trunk **bit-exact** (code-path-skip toggles), gated
+  before and after every training run.
+- Every result reads against the exp000 zero-shot baseline wall below; paired
+  designs with derangement (no-fixed-point) controls; judges self-test on known
+  answers before scoring; 1-seed results ship as **candidates**.
+
+## Baseline wall (exp000)
+
+CLIP-L image↔image cosine, original vs regenerated from the row's own
+`json_prompt` (`vit_json_prompt` for json-vit), **conditional vs shuffled-JSON
+(derangement)**, n=24 held-out rows of `synthetic-object-relations-json`,
+paired seeds, 30 steps, guidance 6.0, fp32 judge features:
+
+| model | cond | shuffled | **cond − shuffled** |
+|---|---|---|---|
+| json_vit (latest ckpt) | 0.8072 | 0.5568 | **+0.2504** |
+| json_ckpt2500 | 0.7536 | 0.5437 | **+0.2099** |
+| base_lune (18765) | 0.6347 | 0.5272 | **+0.1075** |
+
+Reading: the json-prompt finetunes carry ~2× the base UNet's scene information
+from structured-JSON conditioning. Caveats: n=24, single seed bank; CLIP-L
+image-image cosine has a high floor (~0.988 for pure-noise pairs on identical
+resolution) so gaps live in a narrow band — the paired design is load-bearing.
+
+## Experiments
+
+| exp | question | status |
+|---|---|---|
+| exp000_baselines | zero-shot baseline wall (above) | **shipped** |
+| exp001_sd15_relay | relay-all16 vs matched LoRA-r32 vs frozen, paired val flow-MSE + round-trip | running |
+| exp002_sd15_addrcond | frozen byte-trigram aleph address into the cond stream — 4-arm causal | staged |
+| exp003_sigma_registers | sign-code separations: what is a diffusion "register"? | staged |
+| exp004_anima_relay | relays on the 2B DiT via diffusion-pipe (bf16-matched) | staged |
+| exp005_sdxl_tree4a | the SDXL capacity battery (guidepost/scaffold/skeleton) | designed |
+
+Code for each experiment ships in its folder with `results.json` from the run
+ledger. Substrate modules in `substrate/`.

exp000_baselines/README.md

@@ -0,0 +1,39 @@
+# exp000_baselines — the SD15-Lune zero-shot baseline wall
+
+**Question.** How much scene information do the frozen SD15-Lune variants carry
+from their own structured-JSON conditioning, before any adapter exists? Every
+later adapter claim in this repo reads against these rows.
+
+**Design.** n=24 held-out tail rows of
+`AbstractPhil/synthetic-object-relations-json` (the json trainer's own dataset;
+columns autodetected and printed, never assumed). For each model: generate from
+the row's GT prompt column, **conditional vs shuffled (derangement — no fixed
+points)**, shared per-index seeds, 30 Euler steps on the SHIFT=2.5-warped sigma
+grid (trainer-matched), guidance 6.0, 512px. Judge: CLIP-L (openai
+clip-vit-large-patch14) image features fp32, cosine of regenerated vs original
+image, after a known-answer self-test (self-cos > 0.999; noise-pair below).
+
+**Results** (`results.json`):
+
+| model | cond col | cond | shuffled | gap |
+|---|---|---|---|---|
+| json_vit (auto latest) | vit_json_prompt | 0.8072 | 0.5568 | **+0.2504** |
+| json_ckpt2500 | json_prompt | 0.7536 | 0.5437 | **+0.2099** |
+| base_lune 18765 | json_prompt | 0.6347 | 0.5272 | **+0.1075** |
+
+**Reading.** Both json finetunes roughly double the base UNet's conditional
+grounding; json_vit is the strongest carrier. The shuffled columns sit near
+each other (0.53–0.56) — the derangement control behaves.
+
+**Honest caveats.** Single seed bank (candidate rows); n=24; CLIP-L img-img
+cosine has a high floor (noise pairs ≈0.988 at matched resolution), so only the
+paired gap is meaningful, never the absolute cosine; generation ran fp16
+(inference-only; judge features fp32); guidance 6.0 follows the
+before/after reference bed (an earlier prototype bed used 4.0 — not
+comparable). Sample images: `*_0.png` (first row per arm).
+
+**Ops note.** The judge self-test caught a transformers-5 API change
+(`get_image_features` returning an output object) before any GPU spend —
+scorer known-answer self-tests are a standing gate of this line.
+
+GPU cost: ~4 minutes total on an RTX 6000 Ada (all three models, both arms).

exp000_baselines/d1_exp000_baselines.py

@@ -0,0 +1,202 @@
+"""d1_exp000_baselines.py — exp000: the SD15-Lune zero-shot baseline wall.
+
+Every later adapter claim reads against these rows (claims discipline). For
+each frozen model {json-prompt ckpt-2500, base lune 18765}: generate from GT
+json_prompt CONDITIONAL vs SHUFFLED-json (derangement — no fixed points), CLIP-L
+image-image cosine original-vs-regen per arm. The cond-minus-shuffled gap is
+the scene-information gauge (pod/v35_expP1_sd15.py judge, contract-checked).
+
+Data: AbstractPhil/synthetic-object-relations-json (the json trainer's own
+dataset), parquet-direct, held-out tail rows, columns AUTODETECTED and printed
+(never assumed). Sampler: pod2/d1_lune_sampler.py (SHIFT=2.5 grid — the
+trainer-matched sampler of record). All judge features fp32.
+
+Local:  python pod2/d1_exp000_baselines.py --smoke     (parse only)
+Pod:    python pod2/d1_exp000_baselines.py --run       (GPU; ledgered)
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+
+sys.path[:0] = ["pod2", "."]
+
+import torch
+
+from pod_ledger import ledger_run, note
+from aleph_diffusion_core import derangement
+from d1_lune_sampler import encode_clip_225, flow_sample, decode
+
+DATASET = "AbstractPhil/synthetic-object-relations-json"
+SD_BASE = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+MODELS = [
+    ("json_ckpt2500", "AbstractPhil/sd15-flow-lune-json-prompt",
+     "checkpoint-00002500/unet", "json_prompt"),
+    ("base_lune", "AbstractPhil/sd15-flow-lune-flux",
+     "flux_t2_6_pose_t4_6_port_t1_4/checkpoint-00018765/unet", "json_prompt"),
+    ("json_vit", "AbstractPhil/sd15-flow-lune-json-vit",
+     "auto", "vit_json_prompt"),
+]
+N, STEPS, GUIDANCE, SEED = 24, 30, 6.0, 1234
+OUT_DIR = ("/workspace/data/dexp000" if os.path.isdir("/workspace")
+           else os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                             "dexp000"))
+
+
+def load_rows(n=N):
+    """Parquet-direct held-out tail; autodetect image + json columns."""
+    from huggingface_hub import HfApi, hf_hub_download
+    import pyarrow.parquet as pq
+    api = HfApi()
+    files = sorted(f for f in api.list_repo_files(DATASET, repo_type="dataset")
+                   if f.endswith(".parquet"))
+    assert files, f"no parquet files in {DATASET}"
+    path = hf_hub_download(DATASET, files[-1], repo_type="dataset")
+    tbl = pq.read_table(path)
+    cols = tbl.column_names
+    print(f"[exp000] columns: {cols}", flush=True)
+    img_col = next((c for c in cols if c in
+                    ("image", "img", "jpeg", "png", "image_bytes")), None)
+    cond_cols = sorted({m[3] for m in MODELS})
+    assert img_col and all(c in cols for c in cond_cols), \
+        f"column autodetect failed (img={img_col}, need {cond_cols}) — inspect"
+    rows = tbl.slice(max(0, tbl.num_rows - n), n).to_pylist()
+    out = []
+    for r in rows:
+        img = r[img_col]
+        if isinstance(img, dict):
+            img = img.get("bytes")
+        row = {"image_bytes": img}
+        for c in cond_cols:
+            v = r[c]
+            row[c] = v if isinstance(v, str) else json.dumps(v)
+        out.append(row)
+    print(f"[exp000] {len(out)} held-out rows (tail of {files[-1]})",
+          flush=True)
+    return out
+
+
+def judge_selftest(clip_model, clip_proc, device):
+    """Known-answer scorer check (silent-zero law): img vs itself == 1,
+    img vs noise well below."""
+    import numpy as np
+    from PIL import Image
+    rng = np.random.default_rng(0)
+    a = Image.fromarray(rng.integers(0, 255, (256, 256, 3), dtype=np.uint8))
+    b = Image.fromarray(rng.integers(0, 255, (256, 256, 3), dtype=np.uint8))
+
+    def feat(im):
+        with torch.no_grad():
+            inp = clip_proc(images=im, return_tensors="pt").to(device)
+            out = clip_model.get_image_features(**inp)
+            if not torch.is_tensor(out):        # transformers>=5 returns an
+                out = getattr(out, "image_embeds", None) \
+                    if getattr(out, "image_embeds", None) is not None \
+                    else out.pooler_output      # output object, not a tensor
+            f = out.float()
+        return torch.nn.functional.normalize(f, dim=-1)
+
+    same = (feat(a) @ feat(a).T).item()
+    diff = (feat(a) @ feat(b).T).item()
+    assert same > 0.999, f"judge self-test: self-cos {same}"
+    assert diff < same, "judge self-test: noise pair >= self pair"
+    print(f"[exp000] judge self-test ok (self {same:.4f}, noise {diff:.4f})",
+          flush=True)
+    return feat
+
+
+def run(device="cuda"):
+    os.makedirs(OUT_DIR, exist_ok=True)
+    import numpy as np
+    from PIL import Image
+    from diffusers import UNet2DConditionModel, AutoencoderKL
+    from transformers import (CLIPTextModel, CLIPTokenizer, CLIPModel,
+                              CLIPProcessor)
+
+    rows = load_rows()
+    perm = derangement(len(rows), seed=SEED)
+
+    vae = AutoencoderKL.from_pretrained(
+        SD_BASE, subfolder="vae", torch_dtype=torch.float32).to(device).eval()
+    tok = CLIPTokenizer.from_pretrained(SD_BASE, subfolder="tokenizer")
+    te = CLIPTextModel.from_pretrained(
+        SD_BASE, subfolder="text_encoder",
+        torch_dtype=torch.float32).to(device).eval()
+    clip = CLIPModel.from_pretrained(
+        "openai/clip-vit-large-patch14",
+        torch_dtype=torch.float32).to(device).eval()
+    cproc = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
+    feat = judge_selftest(clip, cproc, device)
+
+    orig_feats = torch.cat([
+        feat(Image.open(io.BytesIO(r["image_bytes"])).convert("RGB"))
+        for r in rows])
+
+    def resolve_sub(repo, sub):
+        if sub != "auto":
+            return sub
+        from huggingface_hub import HfApi
+        cks = sorted({f.split("/")[0] for f in
+                      HfApi().list_repo_files(repo)
+                      if f.startswith("checkpoint-")})
+        assert cks, f"no checkpoints in {repo}"
+        return f"{cks[-1]}/unet"
+
+    results = {}
+    for label, repo, sub, cond_col in MODELS:
+        prompts = [r[cond_col] for r in rows]
+        shuffled = [prompts[i] for i in perm.tolist()]
+        with torch.no_grad():
+            ehs_cond = encode_clip_225(prompts, tok, te, device)
+            ehs_shuf = encode_clip_225(shuffled, tok, te, device)
+        with ledger_run(f"dexp000 baseline {label}", budget_h=1.0) as h:
+            unet = UNet2DConditionModel.from_pretrained(
+                repo, subfolder=resolve_sub(repo, sub),
+                torch_dtype=torch.float16).to(device)
+            unet.eval()
+            arms = {}
+            for arm, ehs in (("cond", ehs_cond), ("shuffled", ehs_shuf)):
+                imgs = []
+                for i in range(0, len(prompts), 6):
+                    lat = flow_sample(unet, ehs[i:i + 6].half(),
+                                      n_steps=STEPS, guidance=GUIDANCE,
+                                      seed=SEED + i, device=device)
+                    imgs.extend(decode(vae, lat.float()))
+                pil = [Image.fromarray((im * 255).astype(np.uint8))
+                       for im in imgs]
+                f = torch.cat([feat(p) for p in pil])
+                cos = (f * orig_feats).sum(-1)
+                arms[arm] = {"mean_cos": round(cos.mean().item(), 4),
+                             "per_row": [round(c, 4) for c in cos.tolist()]}
+                for j, p in enumerate(pil[:6]):
+                    p.save(os.path.join(OUT_DIR, f"{label}_{arm}_{j}.png"))
+            gap = arms["cond"]["mean_cos"] - arms["shuffled"]["mean_cos"]
+            results[label] = {**arms, "cond_minus_shuffled": round(gap, 4)}
+            h["verdict"] = f"cond-shuf gap {gap:+.4f}"
+            del unet
+            torch.cuda.empty_cache()
+        note(f"exp000 {label}: {json.dumps(results[label]['cond_minus_shuffled'])}")
+
+    with open(os.path.join(OUT_DIR, "results.json"), "w") as f:
+        json.dump({"n": N, "steps": STEPS, "guidance": GUIDANCE, "seed": SEED,
+                   "sampler": "shifted SHIFT=2.5 (trainer-matched)",
+                   "models": results}, f, indent=2)
+    print(json.dumps(results, indent=2))
+    return results
+
+
+def smoke():
+    p = derangement(N, seed=SEED)
+    assert not (p == torch.arange(N)).any()
+    assert len(MODELS) == 3 and all(len(m) == 4 for m in MODELS) and OUT_DIR
+    print("d1_exp000_baselines smoke PASSED (parse + derangement; GPU run is "
+          "pod work)")
+
+
+if __name__ == "__main__":
+    if "--run" in sys.argv:
+        run()
+    else:
+        smoke()

exp000_baselines/results.json

@@ -0,0 +1,192 @@
+{
+  "n": 24,
+  "steps": 30,
+  "guidance": 6.0,
+  "seed": 1234,
+  "sampler": "shifted SHIFT=2.5 (trainer-matched)",
+  "models": {
+    "json_ckpt2500": {
+      "cond": {
+        "mean_cos": 0.7536,
+        "per_row": [
+          0.8035,
+          0.9148,
+          0.7331,
+          0.6688,
+          0.4755,
+          0.7231,
+          0.7083,
+          0.5943,
+          0.7487,
+          0.8701,
+          0.7032,
+          0.8887,
+          0.832,
+          0.9014,
+          0.611,
+          0.8087,
+          0.6524,
+          0.7803,
+          0.8273,
+          0.6996,
+          0.7105,
+          0.8917,
+          0.7518,
+          0.7874
+        ]
+      },
+      "shuffled": {
+        "mean_cos": 0.5437,
+        "per_row": [
+          0.5435,
+          0.6425,
+          0.5901,
+          0.4604,
+          0.5282,
+          0.4898,
+          0.6984,
+          0.4481,
+          0.3883,
+          0.5295,
+          0.6005,
+          0.6636,
+          0.5471,
+          0.7058,
+          0.4693,
+          0.5594,
+          0.5301,
+          0.4889,
+          0.3852,
+          0.503,
+          0.4944,
+          0.4945,
+          0.6633,
+          0.6256
+        ]
+      },
+      "cond_minus_shuffled": 0.2099
+    },
+    "base_lune": {
+      "cond": {
+        "mean_cos": 0.6347,
+        "per_row": [
+          0.5411,
+          0.8111,
+          0.6828,
+          0.6286,
+          0.4581,
+          0.7579,
+          0.6248,
+          0.4867,
+          0.669,
+          0.5588,
+          0.794,
+          0.707,
+          0.6291,
+          0.6393,
+          0.5809,
+          0.6189,
+          0.6138,
+          0.6916,
+          0.5286,
+          0.488,
+          0.6567,
+          0.7892,
+          0.6652,
+          0.6113
+        ]
+      },
+      "shuffled": {
+        "mean_cos": 0.5272,
+        "per_row": [
+          0.4326,
+          0.5854,
+          0.5153,
+          0.5229,
+          0.4735,
+          0.5902,
+          0.6787,
+          0.4701,
+          0.4958,
+          0.5693,
+          0.5736,
+          0.6151,
+          0.5454,
+          0.5444,
+          0.4825,
+          0.5683,
+          0.4995,
+          0.4937,
+          0.4329,
+          0.4747,
+          0.4512,
+          0.4787,
+          0.4917,
+          0.6676
+        ]
+      },
+      "cond_minus_shuffled": 0.1075
+    },
+    "json_vit": {
+      "cond": {
+        "mean_cos": 0.8072,
+        "per_row": [
+          0.8537,
+          0.9141,
+          0.8594,
+          0.7998,
+          0.7337,
+          0.87,
+          0.8184,
+          0.6666,
+          0.7627,
+          0.8301,
+          0.8526,
+          0.9045,
+          0.6834,
+          0.9177,
+          0.8277,
+          0.7235,
+          0.7074,
+          0.9092,
+          0.8024,
+          0.7627,
+          0.7616,
+          0.8436,
+          0.8002,
+          0.7667
+        ]
+      },
+      "shuffled": {
+        "mean_cos": 0.5568,
+        "per_row": [
+          0.5882,
+          0.4861,
+          0.5141,
+          0.5191,
+          0.5185,
+          0.5729,
+          0.6989,
+          0.4491,
+          0.5066,
+          0.5497,
+          0.5242,
+          0.5634,
+          0.5902,
+          0.7063,
+          0.5484,
+          0.5393,
+          0.5639,
+          0.5951,
+          0.4585,
+          0.5238,
+          0.4823,
+          0.5658,
+          0.6907,
+          0.6077
+        ]
+      },
+      "cond_minus_shuffled": 0.2504
+    }
+  }
+}

substrate/aleph_diffusion_core.py

@@ -0,0 +1,450 @@
+"""aleph_diffusion_core.py — runner-2 diffusion aleph-adapter core (exp001+).
+
+The certified components ported to diffusion trunks (repos/geolip-aleph-diffusion.md):
+  AlephAddress    — verbatim port of tools/aleph_routed_attention.py:51 (closed-form
+                    sinh/cosh read over 2K oriented half-axes; canon/aleph_core.md).
+  RelayPatch2D    — the RelayPatchwork port (tools/qwen_exp002_refine.py:96):
+                    per-block residual relay on token-space hidden states [B,T,d].
+                    Zero-init out weight AND bias (exp006 bias-leak law), gate -3.0,
+                    enabled=False returns x via code-path skip (toggle law bit-exact).
+  AlephCondAdapter— conditioning-stream address injection (geolip-sdxl-aleph
+                    addr_adapter precedent): frozen [32,128] address -> 32 cond
+                    positions, everything zero-init => exact zeros at init.
+  Sign-code gauge — register-probe separation, DIAGONAL EXCLUDED (documented
+                    discontinuity vs the qwen line; canon/register_probe_gauge.md).
+  Parity utils    — P-TOGGLE / P-INIT / P-FIRE / P-SAVE gate helpers.
+
+Riders: pure Adam wd=0 downstream; no comparative selectors in any gradient path
+(argmax appears ONLY in read-only gauges); fp32 for paired gauges; no GAP on
+feature paths (pooling appears ONLY in read-only gauges).
+
+CPU cert:  python pod2/aleph_diffusion_core.py   (shapes/parity only — never
+CPU-train for accuracy; house law).
+"""
+from __future__ import annotations
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+PHI = math.sqrt(2.0)
+PSI = 1.533751168755204288118041
+
+
+def super_fibonacci_s3(n: int, dtype=torch.float32) -> torch.Tensor:
+    """Near-uniform unit quaternions (Alexa CVPR'22), constants per canon."""
+    i = torch.arange(n, dtype=torch.float64)
+    s = (i + 0.5) / n
+    r = torch.sqrt(s)
+    R = torch.sqrt(1.0 - s)
+    alpha = 2.0 * math.pi * i / PHI
+    beta = 2.0 * math.pi * i / PSI
+    q = torch.stack([r * torch.sin(alpha), r * torch.cos(alpha),
+                     R * torch.sin(beta), R * torch.cos(beta)], dim=-1)
+    return F.normalize(q, dim=-1).to(dtype)
+
+
+class AlephAddress(nn.Module):
+    """The aleph addresser over 2K oriented half-axes [+A; -A].
+    m_hat(x): closed-form soft read Sum_k sinh(u_k)A_k / Sum_k cosh(u_k), stable
+    via max-|u| factor-out; 2K never materialized. Codebook trains ONLY through
+    whatever consumes the address (no commit/EMA/VQ)."""
+
+    def __init__(self, K: int = 64, D: int = 4, tau: float = 0.1,
+                 init: str = "random", codebook: torch.Tensor | None = None,
+                 learnable: bool = True):
+        super().__init__()
+        self.K, self.D, self.tau = K, D, tau
+        if codebook is not None:
+            A = F.normalize(codebook.detach().clone().float(), dim=-1)
+            assert A.shape == (K, D), f"custom codebook must be ({K},{D})"
+        elif init == "fibonacci":
+            assert D == 4, "fibonacci init is defined on S^3 (D=4) only"
+            A = super_fibonacci_s3(K)
+        elif init == "random":
+            A = F.normalize(torch.randn(K, D), dim=-1)
+        else:
+            raise ValueError(f"unknown init '{init}'")
+        if learnable:
+            self.codebook = nn.Parameter(A)
+        else:
+            self.register_buffer("codebook", A)
+        self.register_buffer("home", A.detach().clone())
+
+    def _u(self, x: torch.Tensor) -> torch.Tensor:
+        A = F.normalize(self.codebook, dim=-1)
+        return (F.normalize(x, dim=-1) @ A.transpose(-1, -2)) / self.tau
+
+    def m_hat(self, x: torch.Tensor) -> torch.Tensor:
+        """Closed-form soft read (decoders read THIS, never the raw codebook)."""
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        num = ep - en                                     # ∝ 2 sinh(u)
+        den = (ep + en).sum(dim=-1, keepdim=True)         # ∝ 2 Σ cosh(u)
+        A = F.normalize(self.codebook, dim=-1)
+        return (num @ A) / den
+
+    @torch.no_grad()
+    def export_codebook(self) -> torch.Tensor:
+        return F.normalize(self.codebook.detach(), dim=-1).clone()
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+class RelayPatch2D(nn.Module):
+    """Per-block residual relay for diffusion token streams.
+    forward(x[B,T,d]) = x + sigmoid(gate) * consume(m_hat(proj(x) slots)).
+    Toggle law: enabled=False returns x UNTOUCHED (code-path skip, bit-exact)."""
+
+    def __init__(self, d: int, n_slots: int = 16, K: int = 64, tau: float = 0.1,
+                 hidden: int = 178, init: str = "random"):
+        super().__init__()
+        self.d, self.n_slots, self.hidden = d, n_slots, hidden
+        self.proj = nn.Linear(d, n_slots * 4, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        self.addr = AlephAddress(K, 4, tau, init)
+        self.consume = nn.Sequential(
+            nn.Linear(n_slots * 4, hidden), SquaredReLU(),
+            nn.LayerNorm(hidden), nn.Linear(hidden, d))
+        nn.init.zeros_(self.consume[-1].weight)   # zero-init out: weight
+        nn.init.zeros_(self.consume[-1].bias)     # AND bias (exp006 law)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+        self.enabled = True                       # plain attr, not a buffer
+        self.telemetry = False                    # read-only ratio stash switch
+        self.last_delta_ratio = None
+
+    def assert_zero_init(self):
+        w, b = self.consume[-1].weight, self.consume[-1].bias
+        assert w.abs().max().item() == 0.0, "out weight not zero-init"
+        assert b.abs().max().item() == 0.0, "out BIAS not zero-init (leak law)"
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if not self.enabled:
+            return x
+        lead = x.shape[:-1]
+        slots = self.proj(x).view(*lead, self.n_slots, 4)
+        feats = self.addr.m_hat(slots).reshape(*lead, self.n_slots * 4)
+        delta = torch.sigmoid(self.gate) * self.consume(feats)
+        if self.telemetry:
+            with torch.no_grad():
+                self.last_delta_ratio = (
+                    delta.norm() / x.norm().clamp_min(1e-12)).item()
+        return x + delta
+
+    @classmethod
+    def from_state_dict(cls, sd: dict) -> "RelayPatch2D":
+        """Rebuild dims FROM the state dict (runner_hook discipline: never trust
+        constructor defaults), then strict-load."""
+        d = sd["proj.weight"].shape[1]
+        n_slots = sd["proj.weight"].shape[0] // 4
+        hidden = sd["consume.0.weight"].shape[0]
+        K = sd["addr.codebook"].shape[0]
+        m = cls(d, n_slots=n_slots, K=K, hidden=hidden)
+        m.load_state_dict(sd, strict=True)
+        return m
+
+
+class BlockWithRelay(nn.Module):
+    """Wrap pattern (pod/v35_substrate.py:182 lineage): adapter reads the
+    hidden-states output of the wrapped block; tuple outputs pass through."""
+
+    def __init__(self, block: nn.Module, relay: nn.Module):
+        super().__init__()
+        self.block = block
+        self.relay = relay
+
+    def forward(self, *args, **kwargs):
+        out = self.block(*args, **kwargs)
+        if isinstance(out, tuple):
+            return (self.relay(out[0]),) + out[1:]
+        return self.relay(out)
+
+
+class AlephCondAdapter(nn.Module):
+    """Frozen [N_ADDR, addr_dim] address -> N_ADDR conditioning positions.
+    Everything zero-init => tokens are EXACT zeros at init and when disabled
+    (the position-presence offset is handled by the bed: SD15 masked-append,
+    Anima write-into-padding)."""
+
+    def __init__(self, cond_dim: int, addr_dim: int = 128, n_addr: int = 32):
+        super().__init__()
+        self.cond_dim, self.addr_dim, self.n_addr = cond_dim, addr_dim, n_addr
+        self.addr_proj = nn.Linear(addr_dim, cond_dim)
+        nn.init.zeros_(self.addr_proj.weight)
+        nn.init.zeros_(self.addr_proj.bias)
+        self.pos_table = nn.Parameter(torch.zeros(n_addr, cond_dim))
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+        self.enabled = True
+
+    def assert_zero_init(self):
+        assert self.addr_proj.weight.abs().max().item() == 0.0
+        assert self.addr_proj.bias.abs().max().item() == 0.0
+        assert self.pos_table.abs().max().item() == 0.0
+
+    def tokens(self, addr: torch.Tensor) -> torch.Tensor:
+        """addr [B, n_addr, addr_dim] -> [B, n_addr, cond_dim]."""
+        assert addr.shape[-2:] == (self.n_addr, self.addr_dim), addr.shape
+        if not self.enabled:
+            return addr.new_zeros(*addr.shape[:-1], self.cond_dim)
+        return torch.sigmoid(self.gate) * (self.addr_proj(addr) + self.pos_table)
+
+    @classmethod
+    def from_state_dict(cls, sd: dict) -> "AlephCondAdapter":
+        cond_dim, addr_dim = sd["addr_proj.weight"].shape
+        n_addr = sd["pos_table"].shape[0]
+        m = cls(cond_dim, addr_dim=addr_dim, n_addr=n_addr)
+        m.load_state_dict(sd, strict=True)
+        return m
+
+
+# ── parity gates ─────────────────────────────────────────────────────────────
+
+def toggle_parity(frozen_fn, adapted_fn, probes, exact: bool = True) -> float:
+    """P-TOGGLE / P-INIT: max |frozen(x) - adapted(x)| over probes.
+    exact=True asserts BIT-EXACT (0.0)."""
+    worst = 0.0
+    with torch.no_grad():
+        for p in probes:
+            a, b = frozen_fn(p), adapted_fn(p)
+            d = (a - b).abs().max().item()
+            worst = max(worst, d)
+    if exact:
+        assert worst == 0.0, f"parity broken: max|delta| = {worst}"
+    return worst
+
+
+class FireCounter:
+    """P-FIRE: forward-hook counters — every adapter fires, none silently dead."""
+
+    def __init__(self, adapters):
+        self.adapters = list(adapters)
+        self.counts = [0] * len(self.adapters)
+        self._handles = []
+
+    def __enter__(self):
+        for i, a in enumerate(self.adapters):
+            def mk(i):
+                def hook(mod, inp, out):
+                    self.counts[i] += 1
+                return hook
+            self._handles.append(a.register_forward_hook(mk(i)))
+        return self
+
+    def __exit__(self, *exc):
+        for h in self._handles:
+            h.remove()
+
+    def assert_all_fired(self, at_least: int = 1):
+        dead = [i for i, c in enumerate(self.counts) if c < at_least]
+        assert not dead, f"adapters never fired at sites {dead}"
+
+
+def save_relay_stack(adapters: nn.ModuleList, path: str):
+    torch.save({"relays": [a.state_dict() for a in adapters]}, path)
+
+
+def load_relay_stack(path: str) -> nn.ModuleList:
+    ck = torch.load(path, map_location="cpu", weights_only=True)
+    return nn.ModuleList(RelayPatch2D.from_state_dict(sd) for sd in ck["relays"])
+
+
+# ── read-only gauges (argmax/pooling legal ONLY here) ────────────────────────
+
+SIGMA_BANDS = ((1.00, 0.75), (0.75, 0.50), (0.50, 0.25), (0.25, 0.00))
+
+
+def sigma_band(sigma: float) -> int:
+    for i, (hi, lo) in enumerate(SIGMA_BANDS):
+        if lo < sigma <= hi or (i == len(SIGMA_BANDS) - 1 and sigma <= hi):
+            return i
+    return 0
+
+
+@torch.no_grad()
+def sign_codes(relay: RelayPatch2D, x: torch.Tensor) -> torch.Tensor:
+    """Per-position per-slot code: winner half-axis id*2 + orientation bit,
+    read from the addressing cosines (read-only hook; gauge, not gradient)."""
+    lead = x.shape[:-1]
+    slots = relay.proj(x).view(*lead, relay.n_slots, relay.addr.D)
+    A = F.normalize(relay.addr.codebook, dim=-1)
+    cos = F.normalize(slots, dim=-1) @ A.transpose(-1, -2)
+    idx = cos.abs().argmax(dim=-1)
+    orient = torch.gather(cos, -1, idx.unsqueeze(-1)).squeeze(-1) > 0
+    return idx * 2 + orient.long()                     # (..., n_slots)
+
+
+@torch.no_grad()
+def separation_no_diag(codes_by_register: dict[str, torch.Tensor]) -> float:
+    """Register separation = mean inter-register Hamming − mean intra-register
+    Hamming, intra DIAGONAL EXCLUDED (the r2 gauge restart; qwen-line numbers
+    are NOT comparable — canon/register_probe_gauge.md). Inter keeps same-input
+    (i,i) cross-register pairs: same input under two registers is a REAL pair
+    (pure register effect), so two near-identical registers read sep ~ -intra/n,
+    not 0. codes: (n_inputs, ..., n_slots) int tensors, inputs ALIGNED across
+    registers (assert same n)."""
+    regs = list(codes_by_register)
+    ns = {codes_by_register[r].shape[0] for r in regs}
+    assert len(ns) == 1, f"unaligned register inputs: {ns}"
+    n = ns.pop()
+    assert n >= max(8, n // 2), "too few aligned inputs"
+
+    def ham(a, b):  # fraction of differing code entries
+        return (a != b).float().mean().item()
+
+    intra, inter = [], []
+    for r in regs:
+        c = codes_by_register[r]
+        for i in range(n):
+            for j in range(i + 1, n):                  # i<j: diagonal excluded
+                intra.append(ham(c[i], c[j]))
+    for a_i in range(len(regs)):
+        for b_i in range(a_i + 1, len(regs)):
+            ca, cb = codes_by_register[regs[a_i]], codes_by_register[regs[b_i]]
+            for i in range(n):
+                for j in range(n):
+                    inter.append(ham(ca[i], cb[j]))
+    return (sum(inter) / max(len(inter), 1)) - (sum(intra) / max(len(intra), 1))
+
+
+def derangement(n: int, seed: int = 0) -> torch.Tensor:
+    """Permutation with NO fixed points (the shuffled-control law)."""
+    g = torch.Generator().manual_seed(seed)
+    while True:
+        p = torch.randperm(n, generator=g)
+        if not (p == torch.arange(n)).any():
+            return p
+
+
+@torch.no_grad()
+def gate_stats(adapters) -> dict:
+    gates = [torch.sigmoid(a.gate).item() for a in adapters if hasattr(a, "gate")]
+    return {"gate_mean": round(sum(gates) / max(len(gates), 1), 5),
+            "gate_min": round(min(gates), 5) if gates else None,
+            "gate_max": round(max(gates), 5) if gates else None}
+
+
+# ── CPU cert suite (shapes/parity ONLY — never CPU-train) ───────────────────
+
+def _smoke():
+    torch.manual_seed(0)
+
+    # 1) super-fibonacci: shape + unit norm
+    q = super_fibonacci_s3(64)
+    assert q.shape == (64, 4)
+    assert (q.norm(dim=-1) - 1).abs().max() < 1e-6
+
+    # 2) closed-form m_hat == explicit 2K softmax read (<=1e-6 fp32)
+    addr = AlephAddress(K=64, D=4)
+    x = torch.randn(5, 7, 16, 4)
+    u = addr._u(x)
+    p = torch.softmax(torch.cat([u, -u], dim=-1), dim=-1)
+    A = F.normalize(addr.codebook, dim=-1)
+    explicit = p[..., :64] @ A - p[..., 64:] @ A
+    assert (addr.m_hat(x) - explicit).abs().max() < 1e-6, "closed form != 2K softmax"
+
+    # 3) RelayPatch2D: zero-init, init parity, toggle parity, shape
+    for d in (320, 640, 1280, 2048):
+        r = RelayPatch2D(d)
+        r.assert_zero_init()
+        xb = torch.randn(2, 9, d)
+        assert torch.equal(r(xb), xb), "P-INIT broken (zero-init must be exact)"
+        r.enabled = False
+        assert r(xb) is xb, "P-TOGGLE broken (must be code-path skip)"
+        r.enabled = True
+        nn.init.normal_(r.consume[-1].weight, std=0.02)   # pretend trained
+        nn.init.normal_(r.consume[-1].bias, std=0.02)
+        assert r(xb).shape == xb.shape and not torch.equal(r(xb), xb)
+    n_params = sum(p.numel() for p in RelayPatch2D(1280).parameters())
+    print(f"  relay params @d=1280: {n_params:,}")
+
+    # 4) toy-stub toggle parity through BlockWithRelay
+    class ToyBlock(nn.Module):
+        def __init__(self, d):
+            super().__init__()
+            self.lin = nn.Linear(d, d)
+
+        def forward(self, x):
+            return x + torch.tanh(self.lin(x))
+
+    d = 64
+    torch.manual_seed(1)
+    frozen = nn.Sequential(ToyBlock(d), ToyBlock(d))
+    relays = nn.ModuleList([RelayPatch2D(d) for _ in range(2)])
+    for rl in relays:                                  # pretend trained
+        nn.init.normal_(rl.consume[-1].weight, std=0.02)
+    wrapped = nn.Sequential(*[BlockWithRelay(b, r)
+                              for b, r in zip(frozen, relays)])
+    probes = [torch.randn(2, 5, d) for _ in range(4)]
+    for rl in relays:
+        rl.enabled = False
+    toggle_parity(lambda p: frozen(p), lambda p: wrapped(p), probes, exact=True)
+    for rl in relays:
+        rl.enabled = True
+    worst = toggle_parity(lambda p: frozen(p), lambda p: wrapped(p), probes,
+                          exact=False)
+    assert worst > 0, "trained adapters produced no delta (dead sites?)"
+
+    # 5) P-FIRE
+    with FireCounter(relays) as fc:
+        wrapped(probes[0])
+    fc.assert_all_fired()
+
+    # 6) P-SAVE: dims-from-state-dict round trip + re-parity
+    import tempfile, os
+    path = os.path.join(tempfile.gettempdir(), "r2_relay_smoke.pt")
+    save_relay_stack(relays, path)
+    relays2 = load_relay_stack(path)
+    for a, b in zip(relays, relays2):
+        for (ka, va), (kb, vb) in zip(a.state_dict().items(),
+                                      b.state_dict().items()):
+            assert ka == kb and torch.equal(va, vb)
+
+    # 7) AlephCondAdapter: exact zeros at init + disabled + round trip
+    for cd in (768, 1024, 2048):
+        c = AlephCondAdapter(cd)
+        c.assert_zero_init()
+        a32 = torch.randn(3, 32, 128)
+        assert c.tokens(a32).abs().max().item() == 0.0, "cond tokens not exact 0"
+        c.enabled = False
+        assert c.tokens(a32).abs().max().item() == 0.0
+        c2 = AlephCondAdapter.from_state_dict(c.state_dict())
+        assert c2.cond_dim == cd
+
+    # 8) sign codes + separation gauge (intra diagonal excluded)
+    r = RelayPatch2D(64)
+    xa = torch.randn(10, 6, 64)
+    codes_a = sign_codes(r, xa)
+    assert codes_a.shape == (10, 6, 16)
+    assert torch.equal(codes_a, sign_codes(r, xa)), "codes not deterministic"
+    # mechanics on constructed codes: intra of constant register = 0 (diagonal
+    # exclusion working), all-differ registers => inter 1 => sep exactly 1.0
+    cz = torch.zeros(10, 6, 16, dtype=torch.long)
+    co = torch.ones(10, 6, 16, dtype=torch.long)
+    assert separation_no_diag({"z": cz, "o": co}) == 1.0
+    assert separation_no_diag({"z": cz, "z2": cz.clone()}) == 0.0
+    # near-identical REAL registers read ~ -intra/n (documented, not a bug)
+    same = separation_no_diag({"a": codes_a, "b": codes_a.clone()})
+    assert same <= 0.0
+    print(f"  sep(identical real)={same:.4f} (expected ~ -intra/n)")
+
+    # 9) derangement: no fixed points
+    for n in (5, 12, 24):
+        p = derangement(n, seed=3)
+        assert not (p == torch.arange(n)).any()
+
+    # 10) sigma bands cover [0,1]
+    assert [sigma_band(s) for s in (1.0, 0.8, 0.6, 0.3, 0.0)] == [0, 0, 1, 2, 3]
+
+    print("aleph_diffusion_core smoke PASSED (closed-form parity, zero-init "
+          "W+b, bit-exact toggles, fire counters, save/load dims-from-sd, "
+          "cond-adapter exact zeros, no-diag gauge, derangement)")
+
+
+if __name__ == "__main__":
+    _smoke()

substrate/d1_lune_sampler.py

@@ -0,0 +1,112 @@
+"""d1_lune_sampler.py — SD15-Lune rectified-flow sampler + 225-token CLIP encoder.
+
+PORTED VERBATIM (read-only law) from E:\\coworkers\\qwen_runner_1\\colab\\
+sd15_lune_before_after.py (the sampler of record — repos/geolip-aleph-diffusion.md):
+  encode_clip_225 — 3 x 75-token chunked CLIP -> [B, 227, 768]. ALL judging in
+                    this line conditions through THIS, never a bare 77-token encode.
+  flow_sample     — Euler ODE sigma 1->0 on the SHIFT-warped grid
+                    sigma = (shift*u)/(1+(shift-1)*u), v = noise - x0, batched CFG.
+                    NOTE: pod/v35_expP1_sd15.py used an UNSHIFTED grid — that
+                    discrepancy is ledgered in R0a; THIS grid matches the trainer.
+Defaults from the source bed: STEPS 30, SHIFT 2.5, VAE_SCALE 0.18215, 64x64
+latents (512px). Guidance differs across Phil's beds (6.0 before/after bed,
+4.0 expP1) — beds pass it explicitly and ledger it.
+
+CPU cert: python pod2/d1_lune_sampler.py  (sigma-grid math + dummy-UNet
+integration shape check only; real sampling is pod work).
+"""
+from __future__ import annotations
+
+import torch
+
+VAE_SCALE = 0.18215
+SHIFT = 2.5
+STEPS = 30
+
+
+def encode_clip_225(prompts, tokenizer, text_encoder, device):
+    """Encode text as 3 x 75-token chunks -> one 227-length hidden sequence."""
+    chunk_len = tokenizer.model_max_length          # 77
+    body_len = chunk_len - 2                        # 75
+    n_chunks = 3
+    ids = tokenizer(prompts, padding="max_length",
+                    max_length=body_len * n_chunks + 2,
+                    truncation=True, return_tensors="pt").input_ids   # [B, 227]
+    bos, eos = ids[:, :1], ids[:, -1:]
+    chunks = []
+    for k in range(n_chunks):
+        s = 1 + k * body_len
+        chunks.append(torch.cat([bos, ids[:, s:s + body_len], eos], dim=1))
+    ids = torch.stack(chunks, dim=1).reshape(-1, chunk_len).to(device)
+    hs = text_encoder(ids)[0]                                   # [B*3, 77, 768]
+    hs = hs.reshape(len(prompts), n_chunks * chunk_len, -1)
+    out = [hs[:, :1]]
+    for k in range(n_chunks):
+        s = k * chunk_len + 1
+        out.append(hs[:, s:s + body_len])
+    out.append(hs[:, -1:])
+    return torch.cat(out, dim=1)                                # [B, 227, 768]
+
+
+def shifted_sigmas(n_steps: int, shift: float = SHIFT,
+                   device="cpu") -> torch.Tensor:
+    u = torch.linspace(1.0, 0.0, n_steps + 1, device=device)
+    return (shift * u) / (1 + (shift - 1) * u)
+
+
+@torch.no_grad()
+def flow_sample(unet, ehs_cond, *, n_steps=STEPS, guidance=6.0, shift=SHIFT,
+                seed=1234, device="cuda", latent_hw=64,
+                encoder_attention_mask=None):
+    """Integrate the rectified-flow ODE sigma 1->0; unet predicts v = noise - x0.
+    encoder_attention_mask (optional, [2B, L]): the Tier-A masked-append toggle
+    path — passed through to the UNet when provided."""
+    B = ehs_cond.shape[0]
+    g = torch.Generator(device=device).manual_seed(seed)
+    x = torch.randn(B, 4, latent_hw, latent_hw, generator=g, device=device,
+                    dtype=torch.float32).to(ehs_cond.dtype)   # noise drawn fp32
+    # for seed comparability across dtypes, then cast to the UNet's dtype
+    ehs_in = torch.cat([ehs_cond, torch.zeros_like(ehs_cond)], dim=0)
+    sigmas = shifted_sigmas(n_steps, shift, device)
+    kw = {}
+    if encoder_attention_mask is not None:
+        kw["encoder_attention_mask"] = encoder_attention_mask
+    for i in range(n_steps):
+        s, s_next = float(sigmas[i]), float(sigmas[i + 1])
+        t = torch.full((2 * B,), s * 1000.0, device=device)
+        v = unet(torch.cat([x, x], dim=0), t, ehs_in, return_dict=False,
+                 **kw)[0]
+        v_cond, v_uncond = v.chunk(2)
+        v = v_uncond + guidance * (v_cond - v_uncond)
+        x = x + (s_next - s) * v                                # Euler (sigma down)
+    return x
+
+
+@torch.no_grad()
+def decode(vae, latents):
+    img = vae.decode(latents / VAE_SCALE).sample
+    img = (img / 2 + 0.5).clamp(0, 1)
+    return img.permute(0, 2, 3, 1).float().cpu().numpy()
+
+
+def _smoke():
+    s = shifted_sigmas(30)
+    assert abs(float(s[0]) - 1.0) < 1e-6 and abs(float(s[-1])) < 1e-6, \
+        "shifted grid must span 1 -> 0 exactly"
+    assert (s[:-1] > s[1:]).all(), "sigmas must be strictly decreasing"
+    mid_shifted = float(shifted_sigmas(2)[1])       # u=0.5 -> 2.5*.5/1.75
+    assert abs(mid_shifted - (1.25 / 1.75)) < 1e-6, "SHIFT=2.5 warp wrong"
+
+    class DummyUNet:
+        def __call__(self, x, t, ehs, return_dict=False, **kw):
+            return (torch.zeros_like(x),)
+
+    out = flow_sample(DummyUNet(), torch.zeros(2, 227, 768), n_steps=4,
+                      guidance=1.0, seed=0, device="cpu")
+    assert out.shape == (2, 4, 64, 64)
+    print("d1_lune_sampler smoke PASSED (shifted grid endpoints + monotone, "
+          "warp value, dummy integration shape)")
+
+
+if __name__ == "__main__":
+    _smoke()

substrate/d1_substrate.py

@@ -0,0 +1,235 @@
+"""d1_substrate.py — runner-2 diffusion substrate gates (Day 0; no science on
+an uncertified substrate; SUBSTRATE FROZEN AT THE GATE).
+
+Gates (charter: history/plans/2026-07-16_runner2_diffusion_charter.md):
+  G1 env      — torch/cuda/dtype facts; Blackwell sm_120 riders (torch>=2.7/
+                cu128; flash-attn must NOT be installed — SDPA is the path).
+  G2 memory   — set_per_process_memory_fraction(R2_MEM_FRACTION) so overruns
+                fail LOUDLY; card + VRAM printed and ledgered.
+  G3 hf       — HF_TOKEN env-only + whoami.
+  G4 sd15     — ckpt-2500 UNet loads; site enumeration ASSERTS 16
+                BasicTransformerBlocks; relay attach; P-INIT/P-TOGGLE bit-exact
+                parity; P-FIRE; peak_mem + s/step printed.
+  G5 mask     — encoder_attention_mask bit-exact probe (Tier-A toggle path);
+                on failure the masked-append design falls back to length-toggle
+                + measured presence-offset (ledgered, never silent).
+  G6 adam     — plain torch.optim.Adam constructs and IS Adam (never AdamW).
+
+Local:  python pod2/d1_substrate.py --smoke   (parse/shape gates only)
+Pod:    python pod2/d1_substrate.py --gate    (all gates, GPU)
+"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+
+sys.path[:0] = ["pod2", "."]
+
+import torch
+
+from aleph_diffusion_core import (RelayPatch2D, BlockWithRelay, FireCounter,
+                                  toggle_parity)
+
+SD_REPO = "AbstractPhil/sd15-flow-lune-json-prompt"
+SD_SUB = "checkpoint-00002500/unet"
+SD_BASE = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+EXPECTED_SD15_SITES = 16
+MEM_FRACTION = float(os.environ.get("R2_MEM_FRACTION", "0.92"))
+
+
+def gate_env():
+    info = {"torch": torch.__version__,
+            "cuda_available": torch.cuda.is_available()}
+    if torch.cuda.is_available():
+        cap = torch.cuda.get_device_capability(0)
+        info["device"] = torch.cuda.get_device_name(0)
+        info["sm"] = f"sm_{cap[0]}{cap[1]}"
+        info["vram_gb"] = round(
+            torch.cuda.get_device_properties(0).total_memory / 2**30, 1)
+        if cap >= (12, 0):
+            try:
+                import flash_attn  # noqa: F401
+                raise AssertionError(
+                    "flash-attn installed on sm_120 — BROKEN there; uninstall "
+                    "(SDPA is the sanctioned path, repos/anima-trainer.md)")
+            except ImportError:
+                pass
+            maj, mnr = torch.__version__.split(".")[:2]
+            assert (int(maj), int(mnr)) >= (2, 7), \
+                "Blackwell sm_120 needs torch>=2.7/cu128"
+    print(f"[G1 env] {info}", flush=True)
+    return info
+
+
+def gate_memory():
+    assert torch.cuda.is_available(), "G2 needs the pod GPU"
+    torch.cuda.set_per_process_memory_fraction(MEM_FRACTION, 0)
+    total = torch.cuda.get_device_properties(0).total_memory / 2**30
+    print(f"[G2 mem] fraction {MEM_FRACTION} of {total:.1f}GB "
+          f"(~{MEM_FRACTION * total:.1f}GB) — overruns now fail LOUDLY",
+          flush=True)
+
+
+def gate_hf():
+    assert os.environ.get("HF_TOKEN"), "HF_TOKEN missing from env (env-only law)"
+    from huggingface_hub import whoami
+    print(f"[G3 hf] identity: {whoami()['name']}", flush=True)
+
+
+def enumerate_sd15_sites(unet):
+    """Walk named_modules; return [(qualified_name, block, width)] for every
+    BasicTransformerBlock. NEVER trust a hardcoded count — assert it."""
+    from diffusers.models.attention import BasicTransformerBlock
+    sites = []
+    for name, mod in unet.named_modules():
+        if isinstance(mod, BasicTransformerBlock):
+            sites.append((name, mod, mod.norm1.normalized_shape[0]))
+    return sites
+
+
+def attach_relays(unet, site_filter=None):
+    """Wrap each BasicTransformerBlock with BlockWithRelay(RelayPatch2D(d)).
+    Returns nn.ModuleList of relays (fp32) in site order."""
+    sites = enumerate_sd15_sites(unet)
+    if site_filter:
+        sites = [s for s in sites if site_filter(s[0])]
+    relays = torch.nn.ModuleList()
+    for name, block, d in sites:
+        p0 = next(block.parameters())
+        # DTYPE LAW (Phil 2026-07-16): adapter dtype MATCHES the trunk dtype
+        # (fp32 adapters on a low-precision trunk spin fp32 noise into the
+        # environment). SD15 exp001 trunk is fp32 -> matched by construction.
+        relay = RelayPatch2D(d).to(device=p0.device, dtype=p0.dtype)
+        wrapped = BlockWithRelay(block, relay)
+        parent = unet
+        parts = name.split(".")
+        for p in parts[:-1]:
+            parent = getattr(parent, p) if not p.isdigit() else parent[int(p)]
+        last = parts[-1]
+        if last.isdigit():
+            parent[int(last)] = wrapped
+        else:
+            setattr(parent, last, wrapped)
+        relays.append(relay)
+    return relays, [s[0] for s in sites]
+
+
+def _probe_batch(device, n=2, seed=7, cond_len=227):
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    x = torch.randn(n, 4, 64, 64, generator=g).to(device)
+    t = torch.full((n,), 500.0, device=device)
+    ehs = torch.randn(n, cond_len, 768, generator=g).to(device)
+    return x, t, ehs
+
+
+def gate_sd15(device="cuda"):
+    from diffusers import UNet2DConditionModel
+    t0 = time.time()
+    unet = UNet2DConditionModel.from_pretrained(
+        SD_REPO, subfolder=SD_SUB, torch_dtype=torch.float32).to(device)
+    unet.eval()
+    print(f"[G4 sd15] UNet loaded fp32 in {time.time() - t0:.1f}s", flush=True)
+
+    sites = enumerate_sd15_sites(unet)
+    widths = [w for _, _, w in sites]
+    assert len(sites) == EXPECTED_SD15_SITES, \
+        f"site map changed: {len(sites)} blocks (expected {EXPECTED_SD15_SITES})"
+    print(f"[G4 sd15] {len(sites)} BasicTransformerBlocks, widths {widths}",
+          flush=True)
+
+    probes = [_probe_batch(device, seed=s) for s in (7, 11, 13, 17)]
+    with torch.no_grad():
+        frozen_out = [unet(x, t, ehs, return_dict=False)[0]
+                      for x, t, ehs in probes]
+
+    relays, names = attach_relays(unet)
+    for r in relays:
+        r.assert_zero_init()                            # P-INIT precondition
+
+    def adapted(i):
+        x, t, ehs = probes[i]
+        with torch.no_grad():
+            return unet(x, t, ehs, return_dict=False)[0]
+
+    # P-INIT: zero-init enabled adapters == frozen, bit-exact
+    worst = max((adapted(i) - frozen_out[i]).abs().max().item()
+                for i in range(len(probes)))
+    assert worst == 0.0, f"P-INIT broken: max|delta| {worst} (bias leak class?)"
+    # P-TOGGLE: disabled == frozen, bit-exact
+    for r in relays:
+        r.enabled = False
+    worst = max((adapted(i) - frozen_out[i]).abs().max().item()
+                for i in range(len(probes)))
+    assert worst == 0.0, f"P-TOGGLE broken: max|delta| {worst}"
+    for r in relays:
+        r.enabled = True
+    # P-FIRE
+    with FireCounter(relays) as fc:
+        adapted(0)
+    fc.assert_all_fired()
+
+    torch.cuda.reset_peak_memory_stats()
+    t0 = time.time()
+    adapted(0)
+    dt_ = time.time() - t0
+    peak = torch.cuda.max_memory_allocated() / 2**30
+    print(f"[G4 sd15] parity gates GREEN | forward {dt_:.2f}s | "
+          f"peak_mem {peak:.2f}GB", flush=True)
+    return unet, relays, names
+
+
+def gate_mask(unet, device="cuda"):
+    """G5: masked-append vs plain must match; bit-exact preferred, else the
+    delta is MEASURED and the Tier-A design falls back (never silent)."""
+    x, t, ehs = _probe_batch(device, seed=23)
+    extra = torch.randn(ehs.shape[0], 32, 768, device=device)
+    ehs_app = torch.cat([ehs, extra], dim=1)
+    mask = torch.cat([torch.ones(ehs.shape[:2], device=device),
+                      torch.zeros(ehs.shape[0], 32, device=device)],
+                     dim=1).bool()
+    with torch.no_grad():
+        plain = unet(x, t, ehs, return_dict=False)[0]
+        masked = unet(x, t, ehs_app, encoder_attention_mask=mask,
+                      return_dict=False)[0]
+    delta = (plain - masked).abs().max().item()
+    verdict = ("BIT-EXACT" if delta == 0.0 else
+               f"delta {delta:.3e} — masked-append NOT bit-exact; Tier-A "
+               f"toggle falls back to length-toggle + measured offset")
+    print(f"[G5 mask] {verdict}", flush=True)
+    return delta
+
+
+def gate_adam():
+    opt = torch.optim.Adam([torch.nn.Parameter(torch.zeros(2))], lr=1e-3,
+                           weight_decay=0.0)
+    assert type(opt) is torch.optim.Adam and not isinstance(
+        opt, torch.optim.AdamW), "pure-Adam law violated"
+    print("[G6 adam] torch.optim.Adam constructs, wd=0, not AdamW", flush=True)
+
+
+def smoke():
+    """Local parse/shape gates (no GPU, no model downloads)."""
+    gate_adam()
+    r = RelayPatch2D(320)
+    r.assert_zero_init()
+    x = torch.randn(1, 4, 320)
+    assert torch.equal(r(x), x)
+    print("d1_substrate smoke PASSED (adam gate + relay parity, local)")
+
+
+def gate():
+    gate_env()
+    gate_memory()
+    gate_hf()
+    gate_adam()
+    unet, relays, names = gate_sd15()
+    gate_mask(unet)
+    print("[substrate] ALL GATES GREEN — substrate FROZEN", flush=True)
+
+
+if __name__ == "__main__":
+    if "--gate" in sys.argv:
+        gate()
+    else:
+        smoke()

substrate/pod_ledger.py

@@ -0,0 +1,197 @@
+"""pod_ledger.py — RUNNER-2 campaign clock + utilization ledger
+(COPY of runner 1's pod/pod_ledger.py per the charter — never import or edit
+the original; its WINDOW constants are runner 1's live campaign clock.)
+
+WINDOW: PLACEHOLDER 2026-07-16 -> 2026-07-20 UTC — Phil sets the real rental
+window at kickoff; override via env R2_WINDOW_START_UTC / R2_WINDOW_END_UTC
+(ISO, e.g. 2026-07-17T00:00) or edit the constants below THEN, not mid-run.
+
+Usage (pod-side, wraps every run):
+    from pod_ledger import ledger_run, burn_down
+    with ledger_run("dexp001 sd15 relay all16", budget_h=1.5):
+        ...            # the run; row written on exit, verdict settable
+    burn_down()        # print remaining wall/allocated/reserve
+
+Ledger file: JSONL at LEDGER_PATH (pod: /workspace/ledger2/pod2_ledger.jsonl;
+local fallback under GEOLIP_DATA). Rows: {kind: run|note|day_report, name,
+start_utc, end_utc, hours, budget_h, verdict, note}. The daily report for
+Phil aggregates by day + experiment.
+
+Colab/pod-safe: stdlib only.
+"""
+from __future__ import annotations
+import contextlib
+import datetime as dt
+import json
+import os
+
+# r2 window (PLACEHOLDER until kickoff; env-overridable, ISO format)
+def _win(env, default):
+    v = os.environ.get(env)
+    if v:
+        return dt.datetime.fromisoformat(v).replace(tzinfo=dt.timezone.utc)
+    return default
+
+
+WINDOW_START_UTC = _win("R2_WINDOW_START_UTC",
+                        dt.datetime(2026, 7, 16, 0, 0, tzinfo=dt.timezone.utc))
+WINDOW_END_UTC = _win("R2_WINDOW_END_UTC",
+                      dt.datetime(2026, 7, 20, 0, 0, tzinfo=dt.timezone.utc))
+TOTAL_H = (WINDOW_END_UTC - WINDOW_START_UTC).total_seconds() / 3600.0
+RESERVE_H = 12.0
+
+_DEFAULT_DIRS = ("/workspace/ledger2",
+                 os.path.join(os.environ.get("GEOLIP_DATA", "./data"),
+                              "pod_ledger"))
+
+
+def _ledger_path():
+    for d in _DEFAULT_DIRS:
+        try:
+            os.makedirs(d, exist_ok=True)
+            return os.path.join(d, "pod2_ledger.jsonl")
+        except OSError:
+            continue
+    return "pod2_ledger.jsonl"
+
+
+LEDGER_PATH = _ledger_path()
+
+
+def _now():
+    return dt.datetime.now(dt.timezone.utc)
+
+
+def _write(row: dict):
+    row["ts"] = _now().isoformat()
+    with open(LEDGER_PATH, "a", encoding="utf-8") as f:
+        f.write(json.dumps(row) + "\n")
+
+
+def _rows():
+    if not os.path.exists(LEDGER_PATH):
+        return []
+    return [json.loads(l) for l in open(LEDGER_PATH, encoding="utf-8")]
+
+
+def note(text: str):
+    _write({"kind": "note", "note": text})
+    print(f"[ledger] {text}", flush=True)
+
+
+def spent_hours() -> float:
+    return sum(r.get("hours", 0.0) for r in _rows() if r.get("kind") == "run")
+
+
+def wall_remaining_h() -> float:
+    return max(0.0, (WINDOW_END_UTC - _now()).total_seconds() / 3600.0)
+
+
+def burn_down(print_it=True) -> dict:
+    spent = spent_hours()
+    wall = wall_remaining_h()
+    elapsed = TOTAL_H - wall
+    state = {
+        "wall_elapsed_h": round(elapsed, 2),
+        "wall_remaining_h": round(wall, 2),
+        "gpu_hours_ledgered": round(spent, 2),
+        "allocatable_remaining_h": round(max(0.0, wall - RESERVE_H), 2),
+        "reserve_h": RESERVE_H,
+        "utilization_pct_of_elapsed": round(100 * spent / max(elapsed, 0.01),
+                                            1),
+    }
+    if print_it:
+        print(f"[burn-down] wall {state['wall_elapsed_h']:.1f}h elapsed / "
+              f"{state['wall_remaining_h']:.1f}h left | runs "
+              f"{state['gpu_hours_ledgered']:.1f}h ledgered "
+              f"({state['utilization_pct_of_elapsed']:.0f}% of elapsed) | "
+              f"allocatable {state['allocatable_remaining_h']:.1f}h "
+              f"(reserve {RESERVE_H:.0f}h)", flush=True)
+    return state
+
+
+@contextlib.contextmanager
+def ledger_run(name: str, budget_h: float = None):
+    """Time a run; write the row on exit (even on failure, with verdict)."""
+    start = _now()
+    print(f"[ledger] START {name}"
+          + (f" (budget {budget_h}h)" if budget_h else ""), flush=True)
+    holder = {"verdict": None}
+    try:
+        yield holder
+        verdict = holder["verdict"] or "completed"
+    except BaseException as e:
+        verdict = f"FAILED: {type(e).__name__}: {e}"
+        raise
+    finally:
+        end = _now()
+        hours = (end - start).total_seconds() / 3600.0
+        over = (budget_h is not None and hours > budget_h)
+        _write({"kind": "run", "name": name,
+                "start_utc": start.isoformat(), "end_utc": end.isoformat(),
+                "hours": round(hours, 3), "budget_h": budget_h,
+                "over_budget": over, "verdict": verdict})
+        print(f"[ledger] END {name}: {hours:.2f}h"
+              + (" ** OVER BUDGET **" if over else ""), flush=True)
+        burn_down()
+
+
+def day_report() -> str:
+    """Aggregate for Phil's daily check-in."""
+    rows = [r for r in _rows() if r.get("kind") == "run"]
+    by_day = {}
+    for r in rows:
+        day = r["start_utc"][:10]
+        by_day.setdefault(day, []).append(r)
+    lines = ["POD UTILIZATION REPORT", "=" * 40]
+    for day in sorted(by_day):
+        runs = by_day[day]
+        total = sum(r["hours"] for r in runs)
+        lines.append(f"\n{day}: {total:.1f}h across {len(runs)} runs")
+        for r in runs:
+            flag = " **OVER**" if r.get("over_budget") else ""
+            lines.append(f"  {r['hours']:5.2f}h  {r['name']}"
+                         f"  [{str(r['verdict'])[:60]}]{flag}")
+    s = burn_down(print_it=False)
+    lines.append(f"\nWall: {s['wall_elapsed_h']:.1f}h elapsed, "
+                 f"{s['wall_remaining_h']:.1f}h remaining "
+                 f"({s['allocatable_remaining_h']:.1f}h allocatable + "
+                 f"{s['reserve_h']:.0f}h reserve)")
+    report = "\n".join(lines)
+    _write({"kind": "day_report", "note": report})
+    return report
+
+
+def smoke():
+    import tempfile, time
+    global LEDGER_PATH
+    old = LEDGER_PATH
+    LEDGER_PATH = os.path.join(tempfile.gettempdir(), "pod_ledger_smoke.jsonl")
+    if os.path.exists(LEDGER_PATH):
+        os.remove(LEDGER_PATH)
+    note("smoke start")
+    with ledger_run("smoke-run", budget_h=0.00001) as h:   # 0.036s budget
+        time.sleep(0.05)
+        h["verdict"] = "smoke ok"
+    try:
+        with ledger_run("smoke-fail", budget_h=1.0):
+            raise ValueError("boom")
+    except ValueError:
+        pass
+    rows = _rows()
+    kinds = [r["kind"] for r in rows]
+    assert kinds.count("run") == 2
+    runs = [r for r in rows if r["kind"] == "run"]
+    assert runs[0]["verdict"] == "smoke ok" and runs[0]["over_budget"]
+    assert runs[1]["verdict"].startswith("FAILED: ValueError")
+    rep = day_report()
+    assert "smoke-run" in rep and "OVER" in rep
+    s = burn_down(print_it=False)
+    assert 0 <= s["wall_remaining_h"] <= TOTAL_H
+    LEDGER_PATH = old
+    print("pod_ledger smoke passed (run rows, failure verdicts, "
+          "over-budget flags, report, burn-down)")
+
+
+if __name__ == "__main__":
+    smoke()