@@ -94,6 +94,9 @@ jobs:
       - name: Check asset_sheet.py can render every showcase piece and reference
         run: python3 tests/check_asset_sheet_select.py
 
+      - name: Check CLAUDE.md names the reference sets in scripts/gallery_refs.py
+        run: python3 tests/check_reference_sets.py
+
       - name: Check falsifiers declare the budget they target
         run: python3 tests/check_falsifier_targets.py
 
 
@@ -173,8 +173,8 @@ Stage with **explicit paths only** — never `git add -A` or `git add .`. Cursor
 
 - `docs/VISUAL-STYLE.md` is the **binding** render standard; deviations are defects.
 - **Framing gate:** Layer 1 framing is measured, not eyeballed — the example's `--output` render path calls the shared helper `examples/gallery_framing.py` (`check_framing`, exit 10 on violation) before writing the still: hero fill 0.70–0.90 of frame in at least one axis, every element that matters clearing all four edges by ≥ 0.02. The check-only path never invokes it, so smoke runtimes are unaffected. The helper measures; call sites enforce. Bleed compositions call `measure_framing_deviation` and assert their own cap at the call site — `check_framing` has no `deviation=` flag.
-- **Contact-sheet gate:** composite the candidate hero beside the pinned calibration set — currently `armature-bend`, `damped-track-aim`, `bmesh-gear` — commit the composite under `docs/gallery/contact-sheets/`, link it in the PR body, and report per-criterion verdicts (stage darkness, wedge warmth, subject fill, saturation, thumbnail legibility) including mean luminance versus the calibration images. A claim without the committed composite is not acceptable evidence. Re-rendering a hero means regenerating its sheet: `tests/check_contact_sheets.py` (Validate) fails when a sheet's candidate tile no longer matches the hero that ships (#487), and an asset-type piece's asset sheet must be re-rendered in the same commit. **This list is the canonical home of the pinned set** — update it here when a new example outclasses a member; `docs/new-example-prompt.md` points here rather than naming members. The longer "calibration references" list in `docs/VISUAL-STYLE.md` is a style reference, not this contact-sheet set. Tooling: `python scripts/render_hero.py --blender PATH --only NAME` renders the README `--output` command and writes the hero, its 640 card variant, and the preview webps (the one committed PNG-to-webp path); `python scripts/contact_sheet.py NAME` builds the composite in the committed format and prints each tile's luma, stage, wedge warmth and saturation; `python scripts/measure_hero_drift.py` checks committed heroes against what the code renders now.
-- **Asset-sheet gate (asset-type examples — game props/kits):** composite the hero asset rendered alone (neutral three-quarter view, plain studio lighting, no staging tricks, no labels, no comparison props) beside the pinned asset-quality reference set — currently `collision-hull-proxy`, `socket-attach-points`, `vertex-color-ao`, `wheelbarrow`, `apothecary-shelf` — rendered the same way; commit under `docs/gallery/asset-sheets/`, link it in the PR body, and report a verdict. The asset ships only if it is not identifiable as the least-designed object in that lineup — a strong scene can carry a weak model; this gate removes the scene. **This list is the canonical home of the reference set** — update it here when a new asset outclasses a member. A reference may be an example or a showcase piece. Tooling: `python scripts/asset_sheet.py --blender PATH NAME` renders the candidate and this set (read from this line) through `scripts/asset_sheet_panel.py` and writes the composite. The measurable floors behind the gate (naming, material variation, edge treatment) live in `examples/gallery_asset_quality.py` — render path only, same call pattern as `gallery_framing`, exit 11 on violation — with the calibration table and dropped-floor evidence in `docs/VISUAL-STYLE.md` § Asset quality.
+- **Contact-sheet gate:** composite the candidate hero beside the pinned calibration set — currently `armature-bend`, `damped-track-aim`, `bmesh-gear` — commit the composite under `docs/gallery/contact-sheets/`, link it in the PR body, and report per-criterion verdicts (stage darkness, wedge warmth, subject fill, saturation, thumbnail legibility) including mean luminance versus the calibration images. A claim without the committed composite is not acceptable evidence. Re-rendering a hero means regenerating its sheet: `tests/check_contact_sheets.py` (Validate) fails when a sheet's candidate tile no longer matches the hero that ships (#487), and an asset-type piece's asset sheet must be re-rendered in the same commit. **The set lives in `scripts/gallery_refs.py` (`CONTACT_SET`), which the tooling reads; this bullet mirrors it** — when a new example outclasses a member, change both in one commit (`tests/check_reference_sets.py` fails on drift); `docs/new-example-prompt.md` points here rather than naming members. The longer "calibration references" list in `docs/VISUAL-STYLE.md` is a style reference, not this contact-sheet set. Tooling: `python scripts/render_hero.py --blender PATH --only NAME` renders the README `--output` command and writes the hero, its 640 card variant, and the preview webps (the one committed PNG-to-webp path); `python scripts/contact_sheet.py NAME` builds the composite in the committed format and prints each tile's luma, stage, wedge warmth and saturation; `python scripts/measure_hero_drift.py` checks committed heroes against what the code renders now.
+- **Asset-sheet gate (asset-type examples — game props/kits):** composite the hero asset rendered alone (neutral three-quarter view, plain studio lighting, no staging tricks, no labels, no comparison props) beside the pinned asset-quality reference set — currently `collision-hull-proxy`, `socket-attach-points`, `vertex-color-ao`, `wheelbarrow`, `apothecary-shelf` — rendered the same way; commit under `docs/gallery/asset-sheets/`, link it in the PR body, and report a verdict. The asset ships only if it is not identifiable as the least-designed object in that lineup — a strong scene can carry a weak model; this gate removes the scene. **The set lives in `scripts/gallery_refs.py` (`ASSET_SET`), which `scripts/asset_sheet.py` reads; this bullet mirrors it** — when a new asset outclasses a member, change both in one commit (`tests/check_reference_sets.py` fails on drift). A reference may be an example or a showcase piece. Tooling: `python scripts/asset_sheet.py --blender PATH NAME` renders the candidate and this set (read from `scripts/gallery_refs.py`) through `scripts/asset_sheet_panel.py` and writes the composite. The measurable floors behind the gate (naming, material variation, edge treatment) live in `examples/gallery_asset_quality.py` — render path only, same call pattern as `gallery_framing`, exit 11 on violation — with the calibration table and dropped-floor evidence in `docs/VISUAL-STYLE.md` § Asset quality.
 - **Falsification:** every check must be proven to fail once — break the contract, observe the non-zero exit, restore — with the probe and the measured error reported in the PR body. An assertion that cannot fail witnesses nothing.
 - **After gallery regeneration** (`python scripts/build_gallery.py`), read the **generated HTML** character by character — the `<img alt>` text and witnesses callouts in `docs/gallery/index.html` and `docs/gallery/<name>/index.html` — not just `examples/gallery.json`. Precedent: the `teaches.split(".")[0]` bug truncated 14/21 card alts at dotted API paths like `bmesh.ops` while the source JSON looked fine (fixed in PR #68).
 - **Playwright gallery captures:** gallery `<img>` tags lazy-load, so force them first (`document.querySelectorAll('img').forEach(i => i.loading = 'eager')`, then wait). **Scroll the target card into view and take a viewport capture** — `scrollIntoView({block:'center', behavior:'instant'})`, short wait, `browser_take_screenshot` with `fullPage` omitted. A `fullPage` capture is NOT a workaround: on a tall gallery page it renders every card image blank even when the images are verified loaded (`complete === true`, `naturalWidth === 1280`, `opacity === 1`) — measured on the 45-card grid at 1425x4516. Verify load state via `browser_evaluate` rather than trusting the pixels.
 
@@ -153,7 +153,7 @@ per-criterion verdicts including mean luminance of the candidate versus each
 calibration image. The image ships only if it is not sortable as the odd one out in
 that lineup—not merely "looks fine alone." A claim without the committed composite
 is not acceptable evidence. When a new example outclasses a member, update the
-pinned set in `CLAUDE.md`, its canonical home. One successful render command is not
+pinned set in `scripts/gallery_refs.py` and the `CLAUDE.md` bullet that names it. One successful render command is not
 proof that the image is good, and neither is the second.
 
 Asset-sheet gate (required when the subject is a game asset: a prop, kit piece or
 
@@ -33,14 +33,14 @@
 
 import argparse
 import os
-import re
 import subprocess
 import sys
 import tempfile
 from pathlib import Path
 
 from PIL import Image
 
+from gallery_refs import ASSET_SET
 from measure_hero_drift import REPO, entries, render_args
 
 PANEL = (640, 360)
@@ -159,16 +159,9 @@
     "wooden-bucket": (r"^BucketLow$", None),
 }
 
-_REF_LINE = re.compile(r"Asset-sheet gate.*?reference set — currently (.+?) — rendered", re.S)
-
-
 def reference_set() -> list[str]:
-    """The pinned reference set, parsed from its canonical home in CLAUDE.md."""
-    text = (REPO / "CLAUDE.md").read_text(encoding="utf-8")
-    m = _REF_LINE.search(text)
-    if not m:
-        raise SystemExit("could not find the asset-sheet reference set in CLAUDE.md")
-    return re.findall(r"`([a-z0-9-]+)`", m.group(1))
+    """The pinned reference set (scripts/gallery_refs.py; CLAUDE.md mirrors it, #523)."""
+    return list(ASSET_SET)
 
 
 def render_panel(blender: str, entry: dict, png: Path) -> bool:
 
@@ -27,9 +27,9 @@
 import numpy as np
 from PIL import Image, ImageDraw
 
+from gallery_refs import CONTACT_SET as CALIBRATION  # the one pinned set (#523)
 from measure_hero_drift import REPO, entries
 
-CALIBRATION = ("armature-bend", "damped-track-aim", "bmesh-gear")
 TILE = (640, 360)
 GAP, CAPTION = 10, 32
 BG = (22, 23, 26)
 
@@ -0,0 +1,21 @@
+"""The pinned gallery reference sets, defined once (#523). Stdlib only.
+
+CONTACT_SET is the contact-sheet calibration set (scripts/contact_sheet.py
+composites a candidate hero beside it). ASSET_SET is the asset-quality
+reference lineup (scripts/asset_sheet.py renders the candidate beside it, and
+tests/check_asset_sheet_select.py requires a SELECT row for each name).
+
+CLAUDE.md § Quality Gates names both sets for readers; it mirrors this file and
+tests/check_reference_sets.py fails when the two disagree. To change a set,
+edit it here and in that CLAUDE.md bullet in the same commit.
+"""
+
+CONTACT_SET = ("armature-bend", "damped-track-aim", "bmesh-gear")
+
+ASSET_SET = (
+    "collision-hull-proxy",
+    "socket-attach-points",
+    "vertex-color-ao",
+    "wheelbarrow",
+    "apothecary-shelf",
+)
@@ -7,16 +7,15 @@
 that way. This reads SELECT with ast (no Pillow needed) and requires a row for:
 
 - every piece in showcase/gallery.json, and
-- every name in the CLAUDE.md asset-quality reference set (read the same way
-  asset_sheet.reference_set() reads it).
+- every name in the asset-quality reference set (scripts/gallery_refs.py, the
+  same tuple asset_sheet.reference_set() returns).
 
     python tests/check_asset_sheet_select.py      (exit 0 ok, 1 on a gap)
 """
 from __future__ import annotations
 
 import ast
 import json
-import re
 import sys
 from pathlib import Path
 
@@ -33,10 +32,9 @@ def select_keys(root: Path) -> set[str]:
 
 
 def reference_set(root: Path) -> list[str]:
-    src = (root / "scripts" / "asset_sheet.py").read_text(encoding="utf-8")
-    pattern = re.search(r'_REF_LINE = re\.compile\(r"(.+?)", re\.S\)', src).group(1)
-    m = re.search(pattern, (root / "CLAUDE.md").read_text(encoding="utf-8"), re.S)
-    return re.findall(r"`([a-z0-9-]+)`", m.group(1)) if m else []
+    sys.path.insert(0, str(root / "scripts"))
+    from gallery_refs import ASSET_SET
+    return list(ASSET_SET)
 
 
 def check(root: Path = ROOT) -> list[str]:
@@ -46,10 +44,10 @@ def check(root: Path = ROOT) -> list[str]:
     refs = reference_set(root)
     errors = [f"showcase piece {n!r} has no SELECT row in scripts/asset_sheet.py"
               for n in pieces if n not in keys]
-    errors += [f"asset-sheet reference {n!r} (CLAUDE.md) has no SELECT row"
+    errors += [f"asset-sheet reference {n!r} (scripts/gallery_refs.py) has no SELECT row"
                for n in refs if n not in keys]
     if not refs:
-        errors.append("could not read the asset-sheet reference set from CLAUDE.md")
+        errors.append("scripts/gallery_refs.py ASSET_SET is empty")
     return errors
 
 
 
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""CLAUDE.md names the same gallery reference sets as scripts/gallery_refs.py (#523).
+
+The sets used to be parsed out of CLAUDE.md prose by scripts/asset_sheet.py
+(rewording one sentence broke the tool and emptied a gate's list) or hard-coded
+in scripts/contact_sheet.py while CLAUDE.md claimed to be canonical. The code
+now reads scripts/gallery_refs.py; this check keeps the CLAUDE.md bullets an
+accurate mirror. It fails loudly when a bullet cannot be found, never passes on
+an empty read.
+
+    python tests/check_reference_sets.py      (exit 0 ok, 1 on drift)
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "scripts"))
+from gallery_refs import ASSET_SET, CONTACT_SET  # noqa: E402
+
+# Bullet label in CLAUDE.md -> the set it must name.
+BULLETS = {
+    "Contact-sheet gate": CONTACT_SET,
+    "Asset-sheet gate": ASSET_SET,
+}
+
+
+def bullet(text: str, label: str) -> str | None:
+    """The CLAUDE.md list item whose bold label starts with `label`."""
+    m = re.search(rf"^- \*\*{re.escape(label)}[^\n]*(?:\n(?!- |\n|#)[^\n]*)*", text, re.M)
+    return m.group(0) if m else None
+
+
+def named_set(item: str) -> list[str]:
+    """Backticked names after 'currently', up to the end of that sentence."""
+    m = re.search(r"currently(.+?)(?:\.\s|;|\s—\s(?![`]))", item, re.S)
+    span = m.group(1) if m else ""
+    return re.findall(r"`([a-z0-9-]+)`", span)
+
+
+def check(root: Path = ROOT) -> list[str]:
+    text = (root / "CLAUDE.md").read_text(encoding="utf-8")
+    errors = []
+    for label, want in BULLETS.items():
+        item = bullet(text, label)
+        if item is None:
+            errors.append(f"CLAUDE.md has no '- **{label}' bullet")
+            continue
+        got = named_set(item)
+        if not got:
+            errors.append(f"CLAUDE.md '{label}' bullet names no set after 'currently'")
+        elif set(got) != set(want):
+            errors.append(f"CLAUDE.md '{label}' names {got}, scripts/gallery_refs.py has {list(want)}")
+    return errors
+
+
+def main() -> int:
+    errors = check()
+    for e in errors:
+        print(f"::error::{e}", file=sys.stderr)
+    if not errors:
+        print(f"reference sets match CLAUDE.md: contact {len(CONTACT_SET)}, asset {len(ASSET_SET)}")
+    return 1 if errors else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())