Lane E R26 w4: the mint-id fence — my rule was the stale thing (wave 4, E's one line)

THE RED WAS MINE. My R25 slot-id check demanded `sku_` on every real-stock pack — faithfully implementing
C's R25 line, which was written BEFORE MINT EXISTED. It then failed all 14 of G's mint crates, whose ids
honour its every intent: non-positional, seeded, stable, zero reuse. C's ruling names it exactly: "the rule
was the stale thing, not E's check." Fourth hold of the epoch, and the fourth to trace to a rule meeting a
case written before the case existed.

THE FIX IS A FENCE, AND IT IS STRONGER THAN THE RULE IT REPLACES — that was the thing to prove. The easy
green was to drop the prefix check. Instead the form is sourcing-scoped per C §7.2a (R26 w4):
sourcing="real" => `sku_` (a POS copy on a shelf) · sourcing="mint" => `mint_` (a dealgod listing standing
in for one). A crate wearing the other's prefix FAILS.

WHY THIS IS A MONEY BUG, NOT A NAMING BUG — G's judgment, now law. G refused to file dealgod listing ids
under `sku_` to go green the easy way. They were right: tier-2's sold-means-gone looks up POS skus. R24's
id collision entered the WRONG SHOP; the same collision in the money layer SELLS A REAL RECORD out of a
real shop to satisfy a minted stand-in. The gate's error says that, in those words — the cost, not the
rule. The message also distinguishes a fence-crossing from a merely positional id, because they are
different faults and the reader shouldn't have to guess which one bit.

PROVED 7/7 — that the fence BITES, not merely that the red stopped. G's real crate (sku_...) -> PASS ·
G's mint crate (mint_...) -> PASS · mint filed under `sku_` (the exact shortcut G refused) -> FAIL, naming
the fence and the real cost · real wearing `mint_` (the reverse) -> FAIL · positional ids still FAIL in
BOTH sourcings (the old rule's whole intent, retained) · duplicate ids -> FAIL. Loosening would have passed
the first two and lost the last four; this passes the first two and keeps all four.

BOTH OLDER SUITES BROUGHT FORWARD RATHER THAN LEFT TO ROT. The R26 suite's mint fixture wore sku_ ids, so
the fence correctly rejected it — a fixture that fails for a NEW reason has stopped testing what it was
written for. Moved to the mint_ space: 17/17. R25 licence suite: 8/8, tally still firing VIA THE TALLY.
Third round running where the near-miss was a test going quietly stale around a changing contract; it is
the failure mode I now look for first.

Gates: atlas-QA OK — 15 per-shop atlas(es) valid, 15 licence line(s) shown, 0 warning(s) (1 real + 14
mint, every one showing its flag to a human) · validate_manifest exit 0 · qa.sh --strict --matrix
7 passed / 0 failed / 0 warn — QA GREEN.
-> F: your 6/1/0 is now 7/0/0. The beta is yours to tag.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

docs/LANES/LANE_E_NOTES.md

@@ -1,5 +1,40 @@
 # LANE E — cross-lane notes
 
+## Round 26 wave 4 — the mint-id fence: my check was faithful, the rule was stale ⟨v5.0-beta⟩
+
+**The red was mine and the fix is C's ruling.** My R25 slot-id check demanded `sku_` on every real-stock
+pack — faithfully implementing C's R25 line, which was **written before mint existed**. It then failed all
+14 of G's mint crates, whose ids honour its every intent: non-positional, seeded, stable, zero reuse. C's
+ruling names it exactly: *"the rule was the stale thing, not E's check."* Fourth hold of the epoch, and
+the fourth to trace to **a rule meeting a case written before the case existed.**
+
+**The fix is a fence, and it is STRONGER than the rule it replaces — that was the thing to prove.** The
+easy green was to drop the prefix check. Instead the form is now sourcing-scoped per C §7.2a (R26 w4):
+`sourcing:"real"` ⇒ `sku_` (a POS copy on a shelf) · `sourcing:"mint"` ⇒ `mint_` (a dealgod listing
+standing in for one). **A crate wearing the other's prefix FAILS.**
+
+**Why this is a money bug and not a naming bug — G's judgment, now law.** G refused to file dealgod listing
+ids under `sku_` to go green the easy way. They were right: **tier-2's sold-means-gone looks up POS skus.**
+R24's id collision entered the *wrong shop*; the same collision in the money layer **sells a real record
+out of a real shop to satisfy a minted stand-in.** The gate's error says that, in those words — the cost,
+not the rule.
+
+**Proved 7/7 — that the fence bites, not merely that the red stopped.** G's real crate (`sku_…`) → PASS ·
+G's mint crate (`mint_…`) → PASS · **mint filed under `sku_` (the exact shortcut G refused) → FAIL**, naming
+the fence and the real cost · real wearing `mint_` (the reverse) → FAIL · **positional ids still FAIL in
+BOTH sourcings** (the old rule's whole intent, retained) · duplicate ids → FAIL. Loosening would have
+passed the first two and lost the last four; this passes the first two and keeps all four.
+
+**Both older suites brought forward rather than left to rot.** The R26 suite's mint fixture wore `sku_`
+ids, so the fence correctly rejected it — a fixture that fails for a *new* reason has stopped testing what
+it was written for. Moved to the `mint_` space: **17/17**. R25 licence suite: **8/8**, tally still firing
+**via the tally**. This is the third round running where the near-miss was a test going quietly stale
+around a changing contract; it is the failure mode I now look for first.
+
+**Gates:** `atlas-QA OK — 15 per-shop atlas(es) valid, 15 licence line(s) shown, 0 warning(s)` (1 real +
+14 mint, every one showing its flag to a human) · `validate_manifest` exit 0 · **`qa.sh --strict --matrix`
+7 passed / 0 failed / 0 warn — QA GREEN.** F's 6/1/0 is now 7/0/0. **→ F: the beta is yours to tag.**
+
 ## Round 26 — the sourcing arm + the atlas manifest ⟨v5.0-beta⟩
 
 **1. The field is `sourcing`, NOT `tier` — and reading C's contract instead of the brief is the only

pipeline/validate_atlas.py

@@ -70,7 +70,16 @@ REQUIRED_ITEM = ("id", "title", "artist", "price", "price_band", "atlas", "uv")
 # C §7.2a (R25 #3): slot ids derive from the source's stable key, never position, and are unique across
 # ALL packs. A real-stock pack's key is the shop's POS sku → `sku_<POS sku>`; the shipped generic packs own
 # the `rec_`/`boo_`/`toy_` positional namespace and a real-stock pack must not emit into it.
-SLOT_ID_PREFIX = "sku_"
+# C §7.2a as amended (R26 wave 4) — THE PREFIX IS A NAMESPACE FENCE, and the id form is SOURCING-SCOPED.
+# My R25 check demanded `sku_` on every real-stock pack. C wrote that rule before mint existed, so it read
+# as one space when there are two — and it failed 14 legitimate mint crates whose ids honour its every
+# intent (non-positional, seeded, stable, zero reuse). C's ruling: the rule was the stale thing, not the
+# check. The fence is not decoration: `sku_` names a POS copy on a shelf, `mint_` names a dealgod listing
+# standing in for one. G refused to file listing ids under `sku_` to go green the easy way, and that
+# judgment is the law now — tier-2's sold-means-gone looks up POS skus, so a prefix that lies doesn't fail
+# a gate, it SELLS THE WRONG RECORD out of a real shop to satisfy a minted stand-in. Never treat them as
+# one space (same standing note as plan-ids vs godverse-ids).
+SLOT_ID_PREFIX = {"real": "sku_", "mint": "mint_"}
 GENERIC_PACKS = os.path.join(ROOT, "web", "assets", "models", "stock_*_index.json")
 # C §7.2b (R26 #1): `sourcing` — real (that shop's own POS snapshot) vs mint (a seeded sample standing in
 # for a keyed shop with no POS). NOTE the brief called this `tier`; C ruled it CANNOT be — `tier` is already
@@ -266,13 +275,31 @@ def validate_index(path):
     # ── C §7.2a: the slot-id form. Aggregated, not per-item: 120 identical errors bury the one that
     # matters. Uniqueness WITHIN the pack is the dup check above; these two are the cross-pack half.
     if ids:
-        pos = sorted(i for i in ids if not str(i).startswith(SLOT_ID_PREFIX))
-        if pos:
-            errs.append(f"{name}: {len(pos)}/{len(ids)} slot id(s) are not `{SLOT_ID_PREFIX}`-prefixed "
-                        f"(e.g. {pos[:3]}) — C §7.2a: a real-stock id derives from the shop's POS sku, never "
-                        f"from position. Positional ids renumber on every re-bake, so anything holding one "
-                        f"across snapshots (a wallet purchase, tier-2's sold-means-gone) points at a "
-                        f"different record.")
+        # The fence can only be checked once the space is known. An unknown `sourcing` already FAILS above
+        # (§7.2b), so this doesn't leak a pass — but it must not silently half-run either: no space, no
+        # verdict on which prefix belongs.
+        want = SLOT_ID_PREFIX.get(sourcing)
+        if want:
+            wrong = sorted(i for i in ids if not str(i).startswith(want))
+            if wrong:
+                # Name the fence-crossing specifically when the crate wears the OTHER space's prefix — that
+                # is a different (and worse) fault than a merely positional id, and the message should say
+                # which one it is rather than make the reader guess.
+                other = {p for s, p in SLOT_ID_PREFIX.items() if s != sourcing}
+                crossed = sorted(i for i in wrong if any(str(i).startswith(p) for p in other))
+                if crossed:
+                    errs.append(f"{name}: sourcing={sourcing!r} but {len(crossed)}/{len(ids)} slot id(s) wear "
+                                f"another space's prefix (e.g. {crossed[:3]}) — C §7.2a (R26 w4): prefixes are "
+                                f"NAMESPACE FENCES. `sku_` is a POS copy on a shelf; `mint_` is a dealgod "
+                                f"listing standing in for one. A crate wearing the other's prefix is not a "
+                                f"naming slip: tier-2's sold-means-gone looks up POS skus, so this sells a "
+                                f"real record out of a real shop to satisfy a minted stand-in.")
+                else:
+                    errs.append(f"{name}: sourcing={sourcing!r} ⇒ ids must be `{want}`-prefixed, but "
+                                f"{len(wrong)}/{len(ids)} are not (e.g. {wrong[:3]}) — C §7.2a: an id derives "
+                                f"from its source's stable key, never from position. Positional ids renumber "
+                                f"on every re-bake, so anything holding one across snapshots (a wallet "
+                                f"purchase, tier-2's sold-means-gone) points at a different record.")
         gen = generic_pack_ids()
         if not gen:
             # the vacuous-gate law: if the other side of "unique across ALL packs" isn't here, say so —