0.2.1: band-coordinate law fixed (+invariant), dispatch-bank/cond classification fixed, schema v1.1 usage card + SCHEMA.md; code now canonical at github.com/AbstractEyes/amoe-lora

.github/workflows/invariants.yml

@@ -0,0 +1,28 @@
+# The house laws, enforced on every push.
+#
+# The invariant suites are CPU-only and download nothing (they run on tiny
+# synthetic trunks), so this is a cheap, fast guard on the contracts that
+# cost real GPU hours to establish: the toggle law, bit-exact detach, the
+# zero-init inertness contract, the dtype law, and the band-coordinate law.
+name: invariants
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  invariants:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install torch (CPU) + safetensors
+        run: |
+          python -m pip install --upgrade pip
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install safetensors
+      - name: Run the invariant suites
+        run: python tests/test_invariants.py

.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.idea/
+.vscode/
+.pytest_cache/
+
+# adapter weights never live in the code repo — they ship on the hub
+*.pt
+*.safetensors

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 AbstractPhil (AbstractEyes)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -35,10 +35,23 @@ optimized or deep-tested. See *Maturity* below.
 ## Install
 
 ```
-pip install torch          # >= 2.1
-pip install -e .           # extras: .[hf] (LM), .[diffusion] (diffusers+safetensors)
+pip install git+https://github.com/AbstractEyes/amoe-lora            # core
+pip install "amoe-lora[diffusion] @ git+https://github.com/AbstractEyes/amoe-lora"
 ```
 
+or from a checkout: `pip install -e .`, extras `.[hf]` (language trunks)
+and `.[diffusion]` (diffusers + safetensors). torch is a dependency, but
+install the CUDA build that matches your machine first — a blind
+`pip install torch` can replace a working one.
+
+**Code lives on [GitHub](https://github.com/AbstractEyes/amoe-lora)**
+(canonical, CI-guarded); the Hugging Face repo mirrors it as the card.
+The adapter file format is documented in [SCHEMA.md](SCHEMA.md); trained
+adapters live in
+[aleph-diffusion-adapters](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters)
+and load into ComfyUI via
+[comfyui-geolip-amoe-lora](https://github.com/AbstractEyes/comfyui-geolip-amoe-lora).
+
 ## The five verbs
 
 ```python

SCHEMA.md

@@ -0,0 +1,143 @@
+# `amoe.diffusion.anchor` — the adapter file format
+
+One file = one adapter stack for one trunk. The file carries its own
+documentation: a loader can tell you what the adapter is, what it was
+trained on, what it measurably does, how strongly to run it, and what it
+does *not* do — without any external database.
+
+Two containers, same logical content:
+
+| container | when | notes |
+|---|---|---|
+| `.safetensors` | **preferred**, and what ComfyUI loads | meta rides in the safetensors metadata block (str→str) |
+| `.pt` | the campaign's original saves | meta rides as a plain dict under `"meta"` |
+
+## Tensor layout
+
+Flat, one namespace, site index first:
+
+```
+blocks.{site_index}.{param_path}        # in the safetensors key space
+{site_index}.{param_path}               # in memory / in the .pt payload
+```
+
+`site_index` is `0..n_sites-1` in **training enumeration order**.
+
+> ### The ordering law (read this before writing a loader)
+>
+> Site order is diffusers `named_modules()` order, which registers
+> `down_blocks` → `up_blocks` → `mid_block`. **The mid block is LAST**, not
+> in the middle. For SD1.5 the width signature is
+>
+> ```
+> [320,320,640,640,1280,1280, 1280,1280,1280, 640,640,640, 320,320,320, 1280]
+> ```
+>
+> A denoiser's *execution* order is different (`input → middle → output`,
+> giving `…1280,1280,1280,1280…` with mid at index 6). Zipping the two
+> positionally misplaces 7 of 16 sites **and still runs**, producing quietly
+> wrong images. Map by site identity, then verify the width signature —
+> the two orders differ at indices 9 and 15, so the signature catches it.
+> `DiffusionAnchorCheckpoint.widths` reads the signature off the tensors.
+
+## Metadata
+
+### Required (provenance — every file has these)
+
+| field | type | meaning |
+|---|---|---|
+| `format` | str | `"amoe.diffusion.anchor"` |
+| `version` | int/str | `1` |
+| `adapter.kind` | str | `relay` · `multiband3` · `mono` · `bank` · `cond` |
+| `substrate.family` | str | `sd15_unet` · `sdxl_unet` · `cosmos_dit` |
+| `substrate.n_sites` | int | must equal the enumerated site count at attach |
+
+Only `relay` and `multiband3` are **attachable**. `mono` and `bank` are
+matched controls and falsified-routing evidence; `cond` is the Law-2
+negative. Loaders may read them; `attach()` refuses them by design and
+says why.
+
+### Optional (provenance, written when known)
+
+`adapter.*` spec (`n_slots`/`K`/`tau`/`hidden` for relay, `rank` for
+multiband3) · `substrate.base_model_id` · `substrate.site_names` ·
+`substrate.widths` · `objective.kind` (`eps`|`flow`|`v`) ·
+`objective.shift` · `blob.lambda` · `dtype` · `seed` · `recipe.*` ·
+`created` · `content_hash_v2` · `imported_from` · `home_reconstructed`
+
+### Optional (the usage card — schema v1.1)
+
+What a UI renders. All optional, so raw campaign stacks stay valid.
+
+| field | type | meaning |
+|---|---|---|
+| `display_name` | str | human name, e.g. `"SD1.5 Relay — Grounding v1 (seed 0)"` |
+| `usage` | str | what it does and when to reach for it |
+| `evidence` | str | the measured verdict **with numbers and seed status** |
+| `recommended_strength` | float | sane default for a strength slider |
+| `band_roles` | list[str] | multiband only: role per band, LOW→HIGH |
+| `caveats` | list[str] | what it costs, where it fails, what is unverified |
+| `license` | str | SPDX-ish string |
+| `nc` | bool | `true` = non-commercial (derived from NC weights) |
+
+`DiffusionAnchorCheckpoint.card()` returns exactly this block with safe
+defaults filled in.
+
+### Honesty rule for `evidence`
+
+`evidence` states what was measured, at how many seeds, against what
+control — never a marketing claim. If a result is single-seed, it says so.
+If a matched control beat it on the aggregate metric, that goes in
+`evidence` or `caveats`, not omitted. Controls and falsified artifacts
+carry `evidence` describing what they *refuted*; that is their value.
+
+## Worked example
+
+```json
+{
+  "format": "amoe.diffusion.anchor",
+  "version": 1,
+  "display_name": "SD1.5 Multiband — Coarse-to-Fine v1 (seed 0)",
+  "adapter": {"kind": "multiband3", "rank": 16},
+  "substrate": {"family": "sd15_unet", "n_sites": 16,
+                "base_model_id": "stable-diffusion-v1-5/stable-diffusion-v1-5"},
+  "objective": {"kind": "eps"},
+  "band_roles": ["fidelity/detail (LOW noise)",
+                 "continuity/semantics (MID)",
+                 "diversity/structure (HIGH noise)"],
+  "usage": "Three sigma-band experts gated per sampling step. Lesion a band to see what it carries.",
+  "evidence": "exp008, 2 seeds: band lesions surgical 3/3 — own-band damage 50-200x cross-band. A matched rank-48 monolith still edges it on aggregate eps-MSE under uniform pressure.",
+  "recommended_strength": 1.0,
+  "caveats": ["Trained on the stock SD1.5 eps trunk; other trunks are untested.",
+              "The aggregate win belongs to the monolith control — the value here is the band structure, not the loss number."],
+  "license": "MIT", "nc": false,
+  "dtype": "float32", "seed": 0
+}
+```
+
+## Band gating (multiband3 only)
+
+Band windows are cosine crossfades on `s01`, the **normalized discrete
+timestep**:
+
+```
+s01 = t / 1000            # eps trunks — t from the model's own sampling
+s01 = sigma               # flow trunks — the SHIFT-warped sigma
+edges = (0.35, 0.75)      # LAW constants, not tunables
+xfade = 0.06
+```
+
+> `s01` is **not** a noise-level proxy. On the real SD1.5 schedule,
+> `1 - alphas_cumprod[t]` puts 316 of 1000 timesteps in a different band
+> than the one the expert was trained on. In ComfyUI, get it from
+> `model_sampling.timestep(sigma) / 1000`.
+
+## Loader checklist
+
+1. Read meta; reject if `format` is absent or unknown.
+2. Enumerate the host's sites; sort into **training order**.
+3. Assert `n_sites` matches, then assert the width signature matches
+   `checkpoint.widths` — refuse loudly on mismatch.
+4. Cast adapters to the trunk's declared dtype (the dtype law).
+5. `kind` in `{relay, multiband3}` to attach; otherwise explain and stop.
+6. Render `card()` so the user sees provenance, evidence, and caveats.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "amoe-lora"
-version = "0.2.0"
+version = "0.2.1"
 description = "Aleph mixture-of-experts adapters: train, attach, align, detach — with the honesty diagnostics built in. 0.2 adds the diffusion subsystem (amoe.diffusion) and safetensors I/O."
 readme = "README.md"
 requires-python = ">=3.10"

src/amoe/__init__.py

@@ -1,23 +1,23 @@
-"""amoe — aleph mixture-of-experts adapters (train/attach/align/detach).
-
-The productized adapter system from the geolip-aleph research line.
-"LoRA-style" refers to the attach/detach usage pattern, not the math:
-these are aleph-addressed patch heads, not low-rank matrices.
-"""
-from .core.adapter import AdapterSpec, RelayPatchwork, BlockWithAdapter
-from .core.address import AlephAddress
-from .core.dispatch import AnchorDispatch, BlockWithDispatch, set_mask
-from .io.checkpoint import (AnchorCheckpoint, DispatchCheckpoint,
-                            load_anchor, load_dispatch,
-                            import_legacy_keys)
-from .runtime.attach import attach, detach, AttachHandle
-from .train.config import TrainConfig, AlignConfig
-from .train.trainer import train
-from .train.aligner import align
-from . import laws
-
-__version__ = "0.2.0"
-
-# The diffusion subsystem (amoe.diffusion) is imported lazily — its verbs
-# live under `import amoe.diffusion as ad`. Core is pure torch; diffusers
-# is only touched by bindings/samplers/data that need it.
+"""amoe — aleph mixture-of-experts adapters (train/attach/align/detach).
+
+The productized adapter system from the geolip-aleph research line.
+"LoRA-style" refers to the attach/detach usage pattern, not the math:
+these are aleph-addressed patch heads, not low-rank matrices.
+"""
+from .core.adapter import AdapterSpec, RelayPatchwork, BlockWithAdapter
+from .core.address import AlephAddress
+from .core.dispatch import AnchorDispatch, BlockWithDispatch, set_mask
+from .io.checkpoint import (AnchorCheckpoint, DispatchCheckpoint,
+                            load_anchor, load_dispatch,
+                            import_legacy_keys)
+from .runtime.attach import attach, detach, AttachHandle
+from .train.config import TrainConfig, AlignConfig
+from .train.trainer import train
+from .train.aligner import align
+from . import laws
+
+__version__ = "0.2.1"
+
+# The diffusion subsystem (amoe.diffusion) is imported lazily — its verbs
+# live under `import amoe.diffusion as ad`. Core is pure torch; diffusers
+# is only touched by bindings/samplers/data that need it.

src/amoe/diffusion/train/trainer.py

@@ -132,7 +132,18 @@ def train(model, cache: dict, config: "DiffusionTrainConfig | None" = None,
 
         if cfg.objective == "eps":
             t = torch.randint(0, 1000, (bsz,), generator=gd, device=device)
-            s01 = 1 - acp[t]                       # noise level proxy in [0,1]
+            # BAND COORDINATE LAW: s01 = t/1000 — the normalized DISCRETE
+            # timestep, exactly what every certified bed trained on
+            # (dexp008/011/012) and what the proven controller gates on at
+            # inference (dexp010, StepGatedSampler). Do NOT substitute a
+            # noise-level proxy such as 1 - alphas_cumprod[t]: measured on
+            # the real SD1.5 scaled_linear schedule, 316 of 1000 timesteps
+            # land in a DIFFERENT band under that proxy (t=300 trains LOW
+            # but the proxy says MID; t=700 trains MID, proxy says HIGH),
+            # so roughly a third of training would teach the wrong expert
+            # and inference would gate on an axis the stack never learned.
+            # Pinned by testing.assert_band_coordinate.
+            s01 = t.float() / 1000.0
             w = set_w(s01) if cfg.adapter == "multiband3" else None
             x_t = add_noise(lat, noise, t, acp)
             pred = ddp_model(x_t.to(dt), t, ehs.to(dt),

src/amoe/io/checkpoint.py

@@ -104,9 +104,16 @@ DIFF_ANCHOR_FORMAT = "amoe.diffusion.anchor"
 @dataclass
 class DiffusionAnchorCheckpoint:
     """One diffusion adapter stack: adapters keyed "{site_index}.{param}".
-    meta.adapter.kind is 'relay' | 'multiband3' | load-only legacy kinds
-    ('mono', 'bank'). Relay kind requires per-site addr.home (drift
-    gauge); multiband has no address, so the requirement is kind-aware."""
+    meta.adapter.kind is 'relay' | 'multiband3' (attachable) or a
+    load-only kind ('mono', 'bank', 'cond'). Relay kind requires per-site
+    addr.home (drift gauge); the others have no address, so the
+    requirement is kind-aware.
+
+    The meta block is the SELF-DOCUMENTING half of the format — see
+    SCHEMA.md. Everything beyond `adapter`/`substrate` is optional, so
+    raw campaign stacks load unchanged while production artifacts can
+    carry their own usage card (display_name / usage / evidence /
+    recommended_strength / caveats / license)."""
     adapters: dict[str, torch.Tensor]
     meta: dict[str, Any] = field(default_factory=dict)
 
@@ -118,6 +125,45 @@ class DiffusionAnchorCheckpoint:
     def n_sites(self) -> int:
         return len({k.split(".", 1)[0] for k in self.adapters})
 
+    @property
+    def widths(self) -> list[int]:
+        """Per-site hidden width, read from the tensors themselves — the
+        cross-framework ALIGNMENT SIGNATURE. Site order is the training
+        order (diffusers named_modules: down -> up -> mid), which is NOT
+        a denoiser's execution order; any host that enumerates blocks
+        differently must match on this signature, never positionally."""
+        out = []
+        for i in range(self.n_sites):
+            sd = self.per_site(i)
+            for key, dim in (("proj.weight", 1), ("down.0.weight", 1),
+                             ("down.weight", 1), ("addr_proj.weight", 0)):
+                if key in sd:
+                    out.append(int(sd[key].shape[dim]))
+                    break
+            else:
+                raise ValueError(f"site {i}: cannot infer width from "
+                                 f"{sorted(sd)[:6]}")
+        return out
+
+    def card(self) -> dict:
+        """The human-facing subset of meta (schema v1.1), with safe
+        defaults — what a UI should render about this adapter."""
+        m = self.meta
+        return {
+            "display_name": m.get("display_name", m.get("name", "unnamed")),
+            "kind": self.kind,
+            "n_sites": self.n_sites,
+            "trunk": m.get("substrate", {}).get("base_model_id", "unknown"),
+            "objective": m.get("objective", {}).get("kind", "unknown"),
+            "usage": m.get("usage", ""),
+            "evidence": m.get("evidence", ""),
+            "recommended_strength": m.get("recommended_strength", 1.0),
+            "band_roles": m.get("band_roles", []),
+            "caveats": m.get("caveats", []),
+            "license": m.get("license", ""),
+            "nc": bool(m.get("nc", False)),
+        }
+
     def per_site(self, i: int) -> dict[str, torch.Tensor]:
         pre = f"{i}."
         return {k[len(pre):]: v for k, v in self.adapters.items()
@@ -137,14 +183,23 @@ class DiffusionAnchorCheckpoint:
 
 
 def _sd_kind(sd: dict) -> str:
+    """Classify one site's state dict.
+
+    ORDER IS LOAD-BEARING: a dispatch bank carries BOTH `key_proj.weight`
+    and `down.0.weight`, so the bank test MUST come before the multiband
+    test — otherwise every exp007/exp014/exp015 bank silently loads as a
+    multiband3 stack and fails later at module construction.
+    """
     if any(k.endswith("addr.codebook") for k in sd):
         return "relay"
+    if any(k.startswith("key_proj") for k in sd) or "keys" in sd:
+        return "bank"                       # dispatch bank — must precede
+    if "pos_table" in sd:
+        return "cond"                       # AlephCondAdapter (exp002)
     if "down.0.weight" in sd:
         return "multiband3"
     if "down.weight" in sd:
         return "mono"
-    if "key_proj" in sd or "keys" in sd:
-        return "bank"
     return "unknown"
 
 
@@ -203,11 +258,22 @@ def load_diffusion_anchor(path: str, *, substrate: "dict | None" = None
             key = "banks" if "banks" in blob else "monos"
             ck = _flatten_stack(list(blob[key]), kind=_sd_kind(blob[key][0]),
                                 imported_from=f"legacy_{key}")
-            ck.meta["routing_negative"] = (
-                "exp007/014/015: comparative dispatch on diffusion is a "
-                "2-seed falsified line — load for analysis, not deployment")
+        elif _sd_kind(blob) != "unknown":
+            # a FLAT single-module state dict (exp002 AlephCondAdapter):
+            # one "site", stored under index 0 so per_site(0) round-trips
+            ck = _flatten_stack([blob], kind=_sd_kind(blob),
+                                imported_from="legacy_flat_module")
         else:
             raise ValueError(f"unrecognized diffusion anchor at {path}")
+    if ck.kind == "bank":
+        ck.meta.setdefault("routing_negative", (
+            "exp007/014/015: comparative dispatch on diffusion is a 2-seed "
+            "falsified line — load for analysis, not deployment"))
+    if ck.kind == "cond":
+        ck.meta.setdefault("law2_negative", (
+            "exp002: the frozen address beside full text conditioning is "
+            "redundant-in-context (real vs deranged -0.0009); the address "
+            "ALONE steers (+0.0287). Redesign target = complementarity"))
     if ck.kind == "relay":
         blocks = {k.split(".", 1)[0] for k in ck.adapters}
         for b in blocks:

src/amoe/testing/diffusion_invariants.py

@@ -151,6 +151,64 @@ def assert_band_windows():
     assert d < 0.03, f"windows not smooth (max step {d} > theory ~0.0262)"
 
 
+def assert_band_coordinate():
+    """The eps band coordinate is s01 = t/1000 — the normalized DISCRETE
+    timestep. Every certified bed trained on it (dexp008/011/012) and the
+    proven controller gates on it (dexp010). The tempting substitute,
+    1 - alphas_cumprod[t], puts t=500 in a different band entirely, which
+    silently decouples training from inference. This test pins the
+    convention and documents the divergence it guards against."""
+    from ..diffusion.core.multiband import band_of
+
+    # the REAL SD1.5 schedule (scaled_linear betas), not a stand-in: this
+    # is the schedule the shipped eps stacks were trained against
+    betas = torch.linspace(0.00085 ** 0.5, 0.012 ** 0.5, 1000,
+                           dtype=torch.float64) ** 2
+    acp = torch.cumprod(1.0 - betas, dim=0)
+
+    disagreements = [t for t in range(1000)
+                     if band_of(t / 1000.0) != band_of(float(1 - acp[t]))]
+    assert len(disagreements) > 300, (
+        f"only {len(disagreements)} timesteps disagree — the guard is not "
+        "sharp enough to catch a regression; revisit it")
+    # measured on this schedule: 316/1000 timesteps train a DIFFERENT band
+    # under the proxy. t=300 -> trained LOW (0.300) vs proxy MID (0.410);
+    # t=700 -> trained MID (0.700) vs proxy HIGH (0.918).
+    assert band_of(0.300) == 0 and band_of(float(1 - acp[300])) == 1
+    assert band_of(0.700) == 1 and band_of(float(1 - acp[700])) == 2
+
+    # the trainer must use the trained coordinate
+    import inspect
+    from ..diffusion.train import trainer as _tr
+    src = inspect.getsource(_tr.train)
+    assert "t.float() / 1000.0" in src, \
+        "trainer eps band coordinate is not t/1000 (band coordinate law)"
+    assert "1 - acp[t]" not in src, \
+        "trainer still uses the alphas_cumprod proxy for band windows"
+
+    # and the sampler must agree with the trainer
+    src_s = inspect.getsource(
+        __import__("amoe.diffusion.runtime.sampler", fromlist=["x"]))
+    assert "float(t) / 1000.0" in src_s, \
+        "StepGatedSampler eps gate diverged from the training coordinate"
+
+
+def assert_kind_classification():
+    """Dispatch banks carry BOTH key_proj and down.0.weight; the bank test
+    must win, or exp007/014/015 stacks load as multiband3 and blow up at
+    module construction. Flat single-module cond adapters (exp002) must
+    classify too."""
+    from ..io.checkpoint import _sd_kind
+    bank = {"key_proj.weight": None, "down.0.weight": None,
+            "gates": None, "codebook": None}
+    assert _sd_kind(bank) == "bank", "bank misclassified (ordering bug)"
+    assert _sd_kind({"down.0.weight": None, "gates": None}) == "multiband3"
+    assert _sd_kind({"down.weight": None, "gate": None}) == "mono"
+    assert _sd_kind({"pos_table": None, "addr_proj.weight": None}) == "cond"
+    assert _sd_kind({"addr.codebook": None, "proj.weight": None}) == "relay"
+    assert _sd_kind({"nonsense": None}) == "unknown"
+
+
 def assert_flow_x0_recovery():
     from ..diffusion.train.objectives import flow_pieces
     g = torch.Generator().manual_seed(5)
@@ -316,6 +374,8 @@ def assert_align_negative():
 
 def run_all() -> None:
     assert_band_windows()
+    assert_band_coordinate()
+    assert_kind_classification()
     assert_flow_x0_recovery()
     assert_toggle_law_diffusion(tuple_site=False)
     assert_toggle_law_diffusion(tuple_site=True)
@@ -324,8 +384,9 @@ def run_all() -> None:
     assert_checkpoint_roundtrip()
     assert_blob_on_eps_refusal()
     assert_align_negative()
-    print("amoe.diffusion invariants: band windows, exact flow x0, toggle "
-          "law (relay+multiband, tensor+tuple), P-INIT, bit-exact detach, "
+    print("amoe.diffusion invariants: band windows, BAND COORDINATE "
+          "(t/1000), kind classification, exact flow x0, toggle law "
+          "(relay+multiband, tensor+tuple), P-INIT, bit-exact detach, "
           "dtype law, checkpoint round trips (.pt/.safetensors/legacy/"
           "fork), blob-on-eps refusal, align negative — ALL GREEN")