diff --git a/README.md b/README.md
index d6c08cfa..692c5f02 100644
--- a/README.md
+++ b/README.md
@@ -325,7 +325,7 @@ byte images stay straight 8-bit. Also witnesses `EXR color_mode='RGB'` dropping
 </tr>
 <tr>
 <td width="46%" valign="middle">
-<a href="examples/sky-texture-sun-elevation/"><img src="examples/sky-texture-sun-elevation/preview.webp" alt="Sky texture sun elevation: pale glazed jar diptych on a dark floor — left panel low sun at 8 degrees, the jar dim twilight blue under a deep blue zenith, right panel high sun at 55 degrees, the jar bright under a pale daylight sky" /></a>
+<a href="examples/sky-texture-sun-elevation/"><img src="examples/sky-texture-sun-elevation/preview.webp" alt="Sky texture sun elevation: diptych of a red-granite obelisk on a paved plaza lit only by the sky — left panel sun at 8 degrees, navy dusk with an orange horizon glow and the obelisk face raked orange, right panel sun at 55 degrees, bright blue midday sky, sunlit paving and a short shadow" /></a>
 </td>
 <td valign="middle">
 
@@ -336,7 +336,7 @@ code misses across 4.5 → 5.1. `sky_type` is `NISHITA` on 4.5 LTS and
 `MULTIPLE_SCATTERING` on 5.1 (`NISHITA` gone); `dust_density` exists only on 4.5
 (`aerosol_density` on 5.1). Two tiny Cycles EXR zenith probes assert
 `sun_elevation` 8° → 55° brightens zenith (rise **2.25x** / **1.50x**, gate ≥ 1.25).
-Gallery still is a dual-elevation diptych so the contract reads at thumbnail scale.
+Gallery still is a sky-lit obelisk diptych (8° dusk | 55° midday) so the contract reads at thumbnail scale.
 
 </td>
 </tr>
diff --git a/docs/gallery/assets/sky-texture-sun-elevation-hero.webp b/docs/gallery/assets/sky-texture-sun-elevation-hero.webp
index 3799383a..84096824 100644
Binary files a/docs/gallery/assets/sky-texture-sun-elevation-hero.webp and b/docs/gallery/assets/sky-texture-sun-elevation-hero.webp differ
diff --git a/docs/gallery/contact-sheets/sky-texture-sun-elevation-contact-sheet.webp b/docs/gallery/contact-sheets/sky-texture-sun-elevation-contact-sheet.webp
index 4dd92102..be31094a 100644
Binary files a/docs/gallery/contact-sheets/sky-texture-sun-elevation-contact-sheet.webp and b/docs/gallery/contact-sheets/sky-texture-sun-elevation-contact-sheet.webp differ
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 48ed8007..70ba955c 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -717,7 +717,7 @@ <h2><a href="custom-normals-shade/">custom-normals-shade</a></h2>
       </article>
       <article class="card" data-tags="world sky rendering">
         <a class="card-media" href="sky-texture-sun-elevation/" tabindex="-1" aria-hidden="true">
-          <img src="assets/sky-texture-sun-elevation-hero.webp" alt="Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right." loading="lazy" decoding="async" />
+          <img src="assets/sky-texture-sun-elevation-hero.webp" alt="A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="sky-texture-sun-elevation/">sky-texture-sun-elevation</a></h2>
diff --git a/docs/gallery/sky-texture-sun-elevation/index.html b/docs/gallery/sky-texture-sun-elevation/index.html
index 10e8d831..774b1b71 100644
--- a/docs/gallery/sky-texture-sun-elevation/index.html
+++ b/docs/gallery/sky-texture-sun-elevation/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/sky-texture-sun-elevation-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right." />
+  <meta property="og:image:alt" content="A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="sky-texture-sun-elevation — Examples — Blender Developer Tools" />
   <meta name="twitter:description" content="World ShaderNodeTexSky driving Background Color — the sky contract across 4.5 LTS and 5.1. sky_type is NISHITA on 4.5 and MULTIPLE_SCATTERING on 5.1 (NISHITA gone); dust_density exists only on 4.5 (aerosol_density on 5.1). Two tiny Cycles OPEN_EXR zenith probes prove sun_elevation 8 deg to 55 deg brightens zenith (rise 2.25x on 5.1.2, 1.50x on 4.5.11, gate &gt;= 1.25)." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/sky-texture-sun-elevation-hero.webp" />
-  <meta name="twitter:image:alt" content="Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right." />
+  <meta name="twitter:image:alt" content="A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,8 +268,8 @@ <h1>sky-texture-sun-elevation</h1>
     <p>World ShaderNodeTexSky driving Background Color — the sky contract across 4.5 LTS and 5.1. sky_type is NISHITA on 4.5 and MULTIPLE_SCATTERING on 5.1 (NISHITA gone); dust_density exists only on 4.5 (aerosol_density on 5.1). Two tiny Cycles OPEN_EXR zenith probes prove sun_elevation 8 deg to 55 deg brightens zenith (rise 2.25x on 5.1.2, 1.50x on 4.5.11, gate &gt;= 1.25).</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right.">
-      <img src="../assets/sky-texture-sun-elevation-hero.webp" alt="Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees.">
+      <img src="../assets/sky-texture-sun-elevation-hero.webp" alt="A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees." width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the example itself — click to zoom.</p>
     <div class="callout"><span class="tag">witnesses</span> AI code still assigns sky_type=&#x27;NISHITA&#x27; and dust_density on 5.1 — both are wrong (NISHITA removed; dust_density is AttributeError; use MULTIPLE_SCATTERING + aerosol_density). A near-black Background Strength alone is not a sky: Sky must link into Background Color. Elevation that does not brighten zenith fails the rise gate.</div>
@@ -278,16 +278,18 @@ <h1>sky-texture-sun-elevation</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A runnable example that builds a World whose Background Color is driven by <code>ShaderNodeTexSky</code>, then proves <code>sun_elevation</code> is load-bearing with two tiny Cycles EXR zenith probes — and stages a dual-elevation gallery diptych so the contract is visible at thumbnail scale.</p>
+<p>A runnable example that builds a World whose Background Color is driven by <code>ShaderNodeTexSky</code>, then proves <code>sun_elevation</code> is load-bearing with two tiny Cycles EXR zenith probes. The gallery still is a sky study: a red-granite gnomon obelisk on a paved plaza, lit by nothing but the sky, shown at both elevations side by side so the contract reads at thumbnail scale.</p>
 <p><strong>What it witnesses:</strong> the Sky Texture contract AI-generated lighting code most often gets wrong across the 4.5 LTS → 5.1 window.</p>
 <ul><li><strong>Sky must drive Background Color.</strong> A near-black Background Strength alone is not a sky — the check asserts the Sky → Background → World Output links.</li><li><strong><code>sky_type</code> renamed.</strong> 4.5 LTS uses <code>NISHITA</code>; 5.1 replaced it with <code>MULTIPLE_SCATTERING</code> (Nishita&#x27;s successor). Assigning <code>NISHITA</code> on 5.1 fails; the enum no longer lists it.</li><li><strong><code>dust_density</code> → <code>aerosol_density</code>.</strong> 4.5 exposes <code>dust_density</code>; 5.1 raises <code>AttributeError</code> and ships <code>aerosol_density</code> instead. AI code still emits <code>dust_density</code>.</li><li><strong><code>sun_elevation</code> brightens zenith.</strong> Two CPU Cycles OPEN_EXR probes with a straight-up camera, Background Strength 0.05 (unclipped), compare zenith luminance at 8° vs 55°. Measured rise <strong>2.25x</strong> on 5.1.2 and <strong>1.50x</strong> on 4.5.11 LTS (gate ≥ 1.25).</li></ul>
 <p><strong>What each check catches on failure:</strong> broken Sky→Background link (exit 6), wrong <code>sky_type</code> for the running version (exit 3), lost <code>sun_elevation</code> round-trip (exit 4), <code>dust_density</code> / <code>NISHITA</code> present on the wrong side of 5.0 (exit 5), a non-working sky (zenith floor, exit 7), and an elevation that does not brighten zenith (exit 8 — rise below 1.25).</p>
 <p><strong>Version witness:</strong> <code>sky_type</code> and the dust/aerosol rename are the divergence; <code>sun_elevation</code> itself is stable. Zenith rise differs by model (Nishita vs multiple scattering) but clears the same gate on both binaries.</p>
 <h2>Stage deviation</h2>
-<p>World carries a Nishita / multiple-scattering Sky Texture instead of the default near-black Background — the contract <em>is</em> the sky. Gallery still is a dual-elevation diptych (8° | 55°) so failure (identical panels) is visible at thumbnail scale. Layer 1 still holds: <code>view_transform=&#x27;Standard&#x27;</code>, designed materials, chosen camera, no helpers in frame.</p>
-<p>The jar is pale glaze, and the studio key and fill only model its form (70 W and 10 W). With saturated terracotta and a 420 W key, the studio lights lit the jar and both panels looked the same: the sky, the thing under test, was not what lit it. Now the jar reads dim twilight blue under the 8° sun and bright under the 55° sun. Mean luma is about 0.35, above the dark-stage band, which is information under this deviation, not a failure.</p>
-<h2>Framing deviation</h2>
-<p>The hero is the sky itself — a world contract, not an object on the stage. The silhouette matte can only measure the jar in each 640 px panel (about 0.37 x / 0.49 y), so an out-of-band number would be a measurement artifact, not the composition. The diptych is not wired to <code>examples/gallery_framing.py</code>; the helper has no <code>deviation=</code> flag to report through.</p>
+<p>The World carries a Nishita / multiple-scattering Sky Texture instead of the default near-black Background, and there are no studio lights: the contract <em>is</em> the sky, so the sky&#x27;s sun disc is the key and its dome is the fill. The still is a diptych, 8° | 55°, split by a dark 12 px rule, with one Background Strength (0.035) for both panels so <code>sun_elevation</code> is the only variable. If it did not take, the two panels would render identical.</p>
+<p>What reads at a glance: at 8° a deep navy sky with a dusk glow on the left horizon, the obelisk&#x27;s sun face raked orange, the plaza nearly dark and the shadow running long out of frame; at 55° a bright blue sky, a sunlit plaza, and a short shadow ending on the bronze meridian scale inlaid in the paving. The ground runs to the horizon, so there is no void below it.</p>
+<p>Layer 1 still holds: <code>view_transform=&#x27;Standard&#x27;</code>, designed materials (red granite, limestone, bronze, matte gilt, brick-pattern paving), a chosen 35 mm camera on a <code>TRACK_TO</code> aim, no helpers in frame. Standard does not compress highlights, so the render path fails with exit 12 if more than 0.05 % of the still clips to white. The committed still has zero clipped pixels. The pyramidion is matte gilt rather than metal: a metallic cap Fresnel-glinted the 55° sun to pure white at grazing angles, whatever its roughness. Mean luma is about 0.20, reported against the calibration set as information under this deviation.</p>
+<p>The sky&#x27;s <code>sun_rotation</code> is a compass bearing, measured clockwise from +Y. The first draft assumed the opposite convention and put the shadow on the wrong side. <code>_sun_rotation_for_shadow</code> holds the measured mapping.</p>
+<h2>Framing</h2>
+<p>Each 640 × 720 panel is its own frame, and the gnomon is measured in it through <code>examples/gallery_framing.py</code> (exit 10). Both panels share geometry and camera, so one measurement covers both. On 5.2.1 the fill is x 0.566 / y 0.794 and the margins are left 0.100, right 0.334, bottom 0.044, top 0.161. The ground, plaza and meridian inlay are stage.</p>
 <h2>Run</h2>
 <pre><code># Zenith-luminance correctness check (tiny Cycles CPU EXR probes) — the CI check:
 blender --background --python sky_texture_sun_elevation.py --
@@ -295,12 +297,12 @@ <h2>Run</h2>
 # Falsifier: Sky→Background unlinked. Must exit non-zero (world links).
 blender --background --python sky_texture_sun_elevation.py -- --unlink-sky
 
-# Also render the gallery diptych (Cycles):
+# Also render the gallery diptych (Cycles; framing gate exit 10, clip gate exit 12):
 blender --background --python sky_texture_sun_elevation.py -- --output sky.png</code></pre>
 <h2>Exit codes</h2>
 <p>Per-script sequential checks. <code>9</code> is a valid check code; there is no rule against it.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td><code>sky_type</code> is not the identifier for this Blender</td></tr><tr><td>4</td><td><code>sun_elevation</code> round-trip failed</td></tr><tr><td>5</td><td><code>dust_density</code> / <code>aerosol_density</code> / <code>NISHITA</code> / <code>MULTIPLE_SCATTERING</code> trap</td></tr><tr><td>6</td><td>Sky → Background → World Output links broken (<code>--unlink-sky</code> lands here)</td></tr><tr><td>7</td><td>High-elevation zenith luma below floor</td></tr><tr><td>8</td><td>Zenith luma did not rise with elevation</td></tr><tr><td>9</td><td><code>--output</code> produced no file</td></tr></tbody></table></div>
-<p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--unlink-sky</code>.</p>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td><code>sky_type</code> is not the identifier for this Blender</td></tr><tr><td>4</td><td><code>sun_elevation</code> round-trip failed</td></tr><tr><td>5</td><td><code>dust_density</code> / <code>aerosol_density</code> / <code>NISHITA</code> / <code>MULTIPLE_SCATTERING</code> trap</td></tr><tr><td>6</td><td>Sky → Background → World Output links broken (<code>--unlink-sky</code> lands here)</td></tr><tr><td>7</td><td>High-elevation zenith luma below floor</td></tr><tr><td>8</td><td>Zenith luma did not rise with elevation</td></tr><tr><td>9</td><td><code>--output</code> produced no file</td></tr><tr><td>10</td><td><code>--output</code> framing violation (<code>gallery_framing</code>, per panel)</td></tr><tr><td>12</td><td><code>--output</code> still clips to white under Standard (&gt; 0.05 % of pixels)</td></tr></tbody></table></div>
+<p>The <code>blender-smoke</code> workflow runs the check on Blender 5.2 LTS and 4.5 LTS (5.1 on the weekly cron, the <code>needs-5.1</code> PR label, or manual dispatch). Smoke does not pass <code>--output</code> or <code>--unlink-sky</code>, so exits 10 and 12 are render-path only.</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -327,13 +329,20 @@ <h2>Source</h2>
 The sky_type / dust_density version traps are untouched.
 
 By default it runs the correctness check (tiny Cycles CPU renders, no gallery
-still). Pass --output to also render a still:
+still). Pass --output to also render the gallery still: a red-granite gnomon
+obelisk on a paved plaza, lit only by the sky, as an 8 deg | 55 deg diptych.
+The render path gates framing (exit 10, per panel) and clipped highlights
+under Standard (exit 12):
 
     blender --background --python sky_texture_sun_elevation.py --
     blender --background --python sky_texture_sun_elevation.py -- --unlink-sky
     blender --background --python sky_texture_sun_elevation.py -- --output s.png
 &quot;&quot;&quot;</span>
 <span class="k">import</span> bpy, bmesh, sys, os, math, argparse, tempfile, shutil
+<span class="k">from</span> mathutils <span class="k">import</span> Matrix
+
+<span class="c"># Shared framing gate (render path only); see examples/gallery_framing.py.</span>
+sys.path.insert(<span class="n">0</span>, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 
 <span class="c"># Radians: low sun vs high sun for the A/B zenith luminance probe</span>
 ELEV_LOW = math.radians(<span class="n">8.0</span>)
@@ -347,6 +356,8 @@ <h2>Source</h2>
 ZENITH_RISE_MIN = <span class="n">1.25</span>
 <span class="c"># Absolute floor so a black / unlinked world cannot sneak through</span>
 HIGH_ZENITH_MIN = <span class="n">0.05</span>
+<span class="c"># Gallery still samples per panel (Cycles CPU, denoised)</span>
+STILL_SAMPLES = <span class="n">96</span>
 
 
 <span class="k">def</span> eevee_engine_id():
@@ -386,7 +397,7 @@ <h2>Source</h2>
     bg = nt.nodes.new(<span class="s">&quot;ShaderNodeBackground&quot;</span>)
     bg.name = <span class="s">&quot;Background&quot;</span>
     bg.location = (<span class="n">0</span>, <span class="n">0</span>)
-    <span class="c"># Gallery still restores Strength=1.0 in render_still; probe uses PROBE_STRENGTH</span>
+    <span class="c"># The probe drops this to PROBE_STRENGTH; the still uses STILL_STRENGTH</span>
     bg.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">1.0</span>
 
     out = nt.nodes.new(<span class="s">&quot;ShaderNodeOutputWorld&quot;</span>)
@@ -433,46 +444,204 @@ <h2>Source</h2>
     <span class="k">return</span> ob
 
 
-<span class="k">def</span> build_ceramic(sc):
-    <span class="s">&quot;&quot;&quot;A turned jar in pale glaze, so it takes the colour of the sky&#x27;s light.
+<span class="c"># Gnomon-obelisk proportions (metres). The obelisk is a sundial gnomon: its</span>
+<span class="c"># shadow along the bronze meridian scale is how the still reads elevation.</span>
+STEP_SIZES = ((<span class="n">1.56</span>, <span class="n">0.16</span>), (<span class="n">1.18</span>, <span class="n">0.15</span>), (<span class="n">0.82</span>, <span class="n">0.16</span>))  <span class="c"># (square side, height)</span>
+SHAFT_BASE = <span class="n">0.40</span>
+SHAFT_TOP = <span class="n">0.27</span>
+SHAFT_H = <span class="n">2.35</span>
+PYRAMIDION_H = <span class="n">0.24</span>
+<span class="c"># Horizontal direction the shadow falls, from +X counter-clockwise. The camera</span>
+<span class="c"># looks roughly along +Y, so -40 deg throws the shadow to the right and toward</span>
+<span class="c"># the lens: the sun sits behind the obelisk&#x27;s left shoulder, far enough</span>
+<span class="c"># off-axis that its disc stays out of frame and only the dusk glow on the</span>
+<span class="c"># horizon enters the 8 deg panel.</span>
+SHADOW_AZIMUTH = math.radians(-<span class="n">40.0</span>)
+<span class="c"># Obelisk yaw: one visible face turned toward the sun, the other in shade.</span>
+HERO_YAW = math.radians(<span class="n">30.0</span>)
+
+
+<span class="k">def</span> _box(bm, sx, sy, sz, z0=<span class="n">0.0</span>, taper_top=<span class="k">None</span>):
+    <span class="s">&quot;&quot;&quot;Axis-aligned box, base at z0. taper_top scales the top face (a frustum).&quot;&quot;&quot;</span>
+    geom = bmesh.ops.create_cube(bm, size=<span class="n">1.0</span>)
+    verts = [v <span class="k">for</span> v <span class="k">in</span> geom[<span class="s">&quot;verts&quot;</span>]]
+    <span class="k">for</span> v <span class="k">in</span> verts:
+        top = v.co.z &gt; <span class="n">0.0</span>
+        s = taper_top <span class="k">if</span> (top <span class="k">and</span> taper_top <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>) <span class="k">else</span> <span class="n">1.0</span>
+        v.co.x = v.co.x * sx * s
+        v.co.y = v.co.y * sy * s
+        v.co.z = (v.co.z + <span class="n">0.5</span>) * sz + z0
+    <span class="k">return</span> verts
+
+
+<span class="k">def</span> _bevel(ob, width, segments=<span class="n">2</span>):
+    mod = ob.modifiers.new(<span class="s">&quot;Chamfer&quot;</span>, <span class="s">&quot;BEVEL&quot;</span>)
+    mod.width = width
+    mod.segments = segments
+    mod.limit_method = <span class="s">&quot;ANGLE&quot;</span>
+    <span class="k">return</span> mod
+
+
+<span class="k">def</span> _stone_material(name, dark, light, rough, scale):
+    <span class="s">&quot;&quot;&quot;Principled stone with a noise-mixed two-tone base, so it is not a flat fill.&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    b = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = rough
+    spec = b.inputs.get(<span class="s">&quot;Specular IOR Level&quot;</span>) <span class="k">or</span> b.inputs.get(<span class="s">&quot;Specular&quot;</span>)
+    <span class="k">if</span> spec <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        spec.default_value = <span class="n">0.3</span>
+    tc = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    noise = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    noise.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = scale
+    noise.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">6.0</span>
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.35</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = (*dark, <span class="n">1.0</span>)
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.70</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = (*light, <span class="n">1.0</span>)
+    nt.links.new(tc.outputs[<span class="s">&quot;Object&quot;</span>], noise.inputs[<span class="s">&quot;Vector&quot;</span>])
+    nt.links.new(noise.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], b.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    <span class="k">return</span> mat
 
-    Saturated terracotta looked the same under both skies: the clay&#x27;s own
-    orange swamped the change in the light, which is the thing on show.
-    &quot;&quot;&quot;</span>
-    clay = _principled(<span class="s">&quot;Clay&quot;</span>, (<span class="n">0.80</span>, <span class="n">0.78</span>, <span class="n">0.74</span>), rough=<span class="n">0.38</span>, metallic=<span class="n">0.0</span>, specular=<span class="n">0.4</span>)
-    glaze = _principled(<span class="s">&quot;Glaze&quot;</span>, (<span class="n">0.60</span>, <span class="n">0.58</span>, <span class="n">0.55</span>), rough=<span class="n">0.22</span>, metallic=<span class="n">0.0</span>, specular=<span class="n">0.5</span>)
 
-    <span class="k">def</span> body(bm):
-        bmesh.ops.create_cone(
-            bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>,
-            segments=<span class="n">64</span>, radius1=<span class="n">0.62</span>, radius2=<span class="n">0.42</span>, depth=<span class="n">1.35</span>,
-        )
-        <span class="c"># base on the floor (the cone is centred on its depth)</span>
-        bmesh.ops.translate(bm, verts=bm.verts, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.675</span>))
+<span class="k">def</span> _paving_material():
+    <span class="s">&quot;&quot;&quot;Limestone pavers: a Brick texture with a soft mortar, object-space.&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(<span class="s">&quot;Paving&quot;</span>)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    b = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    b.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.82</span>
+    spec = b.inputs.get(<span class="s">&quot;Specular IOR Level&quot;</span>) <span class="k">or</span> b.inputs.get(<span class="s">&quot;Specular&quot;</span>)
+    <span class="k">if</span> spec <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        spec.default_value = <span class="n">0.2</span>
+    tc = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    brick = nt.nodes.new(<span class="s">&quot;ShaderNodeTexBrick&quot;</span>)
+    brick.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = <span class="n">0.9</span>
+    brick.inputs[<span class="s">&quot;Mortar Size&quot;</span>].default_value = <span class="n">0.012</span>
+    brick.inputs[<span class="s">&quot;Color1&quot;</span>].default_value = (<span class="n">0.46</span>, <span class="n">0.40</span>, <span class="n">0.32</span>, <span class="n">1.0</span>)
+    brick.inputs[<span class="s">&quot;Color2&quot;</span>].default_value = (<span class="n">0.39</span>, <span class="n">0.34</span>, <span class="n">0.27</span>, <span class="n">1.0</span>)
+    brick.inputs[<span class="s">&quot;Mortar&quot;</span>].default_value = (<span class="n">0.16</span>, <span class="n">0.14</span>, <span class="n">0.11</span>, <span class="n">1.0</span>)
+    brick.offset = <span class="n">0.5</span>
+    brick.squash = <span class="n">1.0</span>
+    nt.links.new(tc.outputs[<span class="s">&quot;Object&quot;</span>], brick.inputs[<span class="s">&quot;Vector&quot;</span>])
+    nt.links.new(brick.outputs[<span class="s">&quot;Color&quot;</span>], b.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    <span class="k">return</span> mat
 
-    vessel = _mesh_obj(sc, <span class="s">&quot;Vessel&quot;</span>, body, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), clay)
-    bev = vessel.modifiers.new(<span class="s">&quot;Bev&quot;</span>, <span class="s">&quot;BEVEL&quot;</span>)
-    bev.width = <span class="n">0.025</span>
-    bev.segments = <span class="n">3</span>
-    bev.limit_method = <span class="s">&quot;ANGLE&quot;</span>
 
-    <span class="k">def</span> lid(bm):
+<span class="k">def</span> build_ground(sc):
+    <span class="s">&quot;&quot;&quot;Paved plaza on open ground that runs to the horizon: no void below it.&quot;&quot;&quot;</span>
+    ground_mat = _stone_material(
+        <span class="s">&quot;Ground&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.15</span>, <span class="n">0.10</span>), (<span class="n">0.30</span>, <span class="n">0.24</span>, <span class="n">0.17</span>), rough=<span class="n">0.95</span>, scale=<span class="n">0.8</span>,
+    )
+
+    <span class="k">def</span> plane(bm):
+        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">2500.0</span>)
+
+    ground = _mesh_obj(sc, <span class="s">&quot;Ground&quot;</span>, plane, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), ground_mat, smooth=<span class="k">False</span>)
+
+    <span class="k">def</span> disc(bm):
         bmesh.ops.create_cone(
             bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>,
-            segments=<span class="n">48</span>, radius1=<span class="n">0.40</span>, radius2=<span class="n">0.10</span>, depth=<span class="n">0.32</span>,
+            segments=<span class="n">96</span>, radius1=<span class="n">6.5</span>, radius2=<span class="n">6.5</span>, depth=<span class="n">0.04</span>,
         )
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.02</span>))
 
-    knob = _mesh_obj(sc, <span class="s">&quot;Lid&quot;</span>, lid, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">1.48</span>), glaze)
-    <span class="k">return</span> vessel, knob
-
+    plaza = _mesh_obj(sc, <span class="s">&quot;Plaza&quot;</span>, disc, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), _paving_material(), smooth=<span class="k">False</span>)
+    <span class="k">return</span> ground, plaza
 
-<span class="k">def</span> build_floor(sc):
-    mat = _principled(<span class="s">&quot;Floor&quot;</span>, (<span class="n">0.025</span>, <span class="n">0.026</span>, <span class="n">0.030</span>), rough=<span class="n">0.85</span>, specular=<span class="n">0.05</span>)
 
-    <span class="k">def</span> grid(bm):
-        bmesh.ops.create_grid(bm, x_segments=<span class="n">1</span>, y_segments=<span class="n">1</span>, size=<span class="n">60.0</span>)
+<span class="k">def</span> build_gnomon(sc):
+    <span class="s">&quot;&quot;&quot;Red-granite obelisk on a stepped limestone plinth, matte-gilt pyramidion,
+    and a bronze meridian scale inlaid in the paving along the shadow line.
 
-    <span class="k">return</span> _mesh_obj(sc, <span class="s">&quot;Floor&quot;</span>, grid, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), mat, smooth=<span class="k">False</span>)
+    Returns (hero parts, meridian scale). The hero parts are what the
+    framing matte measures; the scale is ground inlay (stage).
+    &quot;&quot;&quot;</span>
+    granite = _stone_material(
+        <span class="s">&quot;RedGranite&quot;</span>, (<span class="n">0.34</span>, <span class="n">0.11</span>, <span class="n">0.07</span>), (<span class="n">0.52</span>, <span class="n">0.22</span>, <span class="n">0.15</span>), rough=<span class="n">0.58</span>, scale=<span class="n">38.0</span>,
+    )
+    limestone = _stone_material(
+        <span class="s">&quot;Limestone&quot;</span>, (<span class="n">0.40</span>, <span class="n">0.36</span>, <span class="n">0.29</span>), (<span class="n">0.50</span>, <span class="n">0.46</span>, <span class="n">0.37</span>), rough=<span class="n">0.78</span>, scale=<span class="n">6.0</span>,
+    )
+    <span class="c"># Matte gilt, not metallic: a metallic cap Fresnel-glinted the 55 deg sun</span>
+    <span class="c"># to pure white at grazing, whatever its roughness.</span>
+    gilt = _principled(<span class="s">&quot;MatteGilt&quot;</span>, (<span class="n">0.42</span>, <span class="n">0.28</span>, <span class="n">0.09</span>), rough=<span class="n">0.6</span>, metallic=<span class="n">0.0</span>, specular=<span class="n">0.3</span>)
+    bronze = _principled(<span class="s">&quot;Bronze&quot;</span>, (<span class="n">0.26</span>, <span class="n">0.17</span>, <span class="n">0.10</span>), rough=<span class="n">0.7</span>, metallic=<span class="n">0.85</span>)
+
+    parts = []
+    z = <span class="n">0.04</span>  <span class="c"># plaza top</span>
+    <span class="k">for</span> i, (side, h) <span class="k">in</span> enumerate(STEP_SIZES):
+        <span class="k">def</span> step(bm, side=side, h=h, z=z):
+            _box(bm, side, side, h, z0=z)
+        ob = _mesh_obj(sc, <span class="s">f&quot;</span><span class="s">PlinthStep</span>{i + <span class="n">1</span>}<span class="s">&quot;</span>, step, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), limestone, smooth=<span class="k">False</span>)
+        _bevel(ob, <span class="n">0.018</span>)
+        parts.append(ob)
+        z += h
+
+    <span class="c"># Dedication plaque on the die face that turns toward the camera.</span>
+    die_side, die_h = STEP_SIZES[-<span class="n">1</span>]
+
+    <span class="k">def</span> plaque(bm, z=z):
+        verts = _box(bm, <span class="n">0.40</span>, <span class="n">0.014</span>, <span class="n">0.085</span>, z0=z - die_h / <span class="n">2.0</span> - <span class="n">0.0425</span>)
+        <span class="k">for</span> v <span class="k">in</span> verts:
+            v.co.y -= die_side / <span class="n">2.0</span> + <span class="n">0.007</span>
+
+    ob = _mesh_obj(sc, <span class="s">&quot;DedicationPlaque&quot;</span>, plaque, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), bronze, smooth=<span class="k">False</span>)
+    _bevel(ob, <span class="n">0.004</span>, segments=<span class="n">1</span>)
+    parts.append(ob)
+
+    <span class="k">def</span> collar(bm, z=z):
+        _box(bm, SHAFT_BASE + <span class="n">0.07</span>, SHAFT_BASE + <span class="n">0.07</span>, <span class="n">0.07</span>, z0=z)
+
+    ob = _mesh_obj(sc, <span class="s">&quot;BronzeCollar&quot;</span>, collar, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), bronze, smooth=<span class="k">False</span>)
+    _bevel(ob, <span class="n">0.012</span>)
+    parts.append(ob)
+    z += <span class="n">0.07</span>
+
+    <span class="k">def</span> shaft(bm, z=z):
+        _box(bm, SHAFT_BASE, SHAFT_BASE, SHAFT_H, z0=z, taper_top=SHAFT_TOP / SHAFT_BASE)
+
+    ob = _mesh_obj(sc, <span class="s">&quot;ObeliskShaft&quot;</span>, shaft, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), granite, smooth=<span class="k">False</span>)
+    _bevel(ob, <span class="n">0.010</span>)
+    parts.append(ob)
+    z += SHAFT_H
+
+    <span class="k">def</span> pyramidion(bm, z=z):
+        bmesh.ops.create_cone(
+            bm, cap_ends=<span class="k">True</span>, cap_tris=<span class="k">False</span>, segments=<span class="n">4</span>,
+            radius1=SHAFT_TOP / math.sqrt(<span class="n">2.0</span>), radius2=<span class="n">0.0</span>, depth=PYRAMIDION_H,
+        )
+        bmesh.ops.rotate(
+            bm, verts=bm.verts, cent=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+            matrix=Matrix.Rotation(math.radians(<span class="n">45.0</span>), <span class="n">3</span>, <span class="s">&quot;Z&quot;</span>),
+        )
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(<span class="n">0.0</span>, <span class="n">0.0</span>, z + PYRAMIDION_H / <span class="n">2.0</span>))
+
+    ob = _mesh_obj(sc, <span class="s">&quot;Pyramidion&quot;</span>, pyramidion, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), gilt, smooth=<span class="k">False</span>)
+    parts.append(ob)
+    <span class="k">for</span> ob <span class="k">in</span> parts:
+        ob.rotation_euler.z = HERO_YAW
+
+    <span class="c"># Meridian scale: a bronze strip from the plinth edge along the shadow</span>
+    <span class="c"># line, with a cross-tick every metre (one hour-line per tick).</span>
+    <span class="k">def</span> scale_bm(bm):
+        start, end = <span class="n">0.95</span>, <span class="n">6.3</span>
+        length = end - start
+        strip = _box(bm, length, <span class="n">0.07</span>, <span class="n">0.012</span>, z0=<span class="n">0.035</span>)
+        <span class="k">for</span> v <span class="k">in</span> strip:
+            v.co.x += start + length / <span class="n">2.0</span>
+        <span class="k">for</span> m <span class="k">in</span> range(<span class="n">1</span>, <span class="n">7</span>):
+            tick = _box(bm, <span class="n">0.035</span>, <span class="n">0.30</span> <span class="k">if</span> m % <span class="n">2</span> == <span class="n">0</span> <span class="k">else</span> <span class="n">0.20</span>, <span class="n">0.012</span>, z0=<span class="n">0.035</span>)
+            <span class="k">for</span> v <span class="k">in</span> tick:
+                v.co.x += float(m)
+        rot = Matrix.Rotation(SHADOW_AZIMUTH, <span class="n">3</span>, <span class="s">&quot;Z&quot;</span>)
+        bmesh.ops.rotate(bm, verts=bm.verts, cent=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), matrix=rot)
+
+    meridian = _mesh_obj(sc, <span class="s">&quot;MeridianScale&quot;</span>, scale_bm, (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>), bronze, smooth=<span class="k">False</span>)
+    <span class="k">return</span> parts, meridian
 
 
 <span class="k">def</span> setup_probe_camera(sc):
@@ -689,65 +858,71 @@ <h2>Source</h2>
     <span class="k">return</span> <span class="n">0</span>
 
 
+<span class="c"># Still: one Background Strength for both panels, so the only variable</span>
+<span class="c"># between them is sun_elevation. Tuned so the brightest pixel in either</span>
+<span class="c"># panel stays below clipping under Standard (which does not compress).</span>
+STILL_STRENGTH = <span class="n">0.035</span>
+PANEL_W, PANEL_H = <span class="n">640</span>, <span class="n">720</span>
+GUTTER = <span class="n">12</span>  <span class="c"># px; a deliberate dark rule between the two panels</span>
+GUTTER_RGB = (<span class="n">0.02</span>, <span class="n">0.021</span>, <span class="n">0.025</span>)
+<span class="c"># Clip gate: fraction of pixels allowed at 8-bit full scale in any channel.</span>
+CLIP_LEVEL = <span class="n">254.5</span> / <span class="n">255.0</span>
+CLIP_MAX_FRACTION = <span class="n">0.0005</span>
+EXIT_CLIPPED = <span class="n">12</span>
+
+
+<span class="k">def</span> _sun_rotation_for_shadow(shadow_azimuth):
+    <span class="s">&quot;&quot;&quot;Sky sun_rotation that puts the sun opposite the given shadow azimuth.
+
+    sun_rotation is a compass bearing: measured clockwise from +Y, so the
+    sun&#x27;s horizontal angle from +X (counter-clockwise) is 90 deg - rotation.
+    Measured, not assumed: the first draft used rotation + 90 deg and threw
+    the shadow to the wrong side of the obelisk.
+    &quot;&quot;&quot;</span>
+    sun_azimuth = shadow_azimuth + math.pi
+    <span class="k">return</span> math.pi / <span class="n">2.0</span> - sun_azimuth
+
+
 <span class="k">def</span> _stage_for_still(sc, world, sky, elevation):
-    <span class="s">&quot;&quot;&quot;Shared beauty staging; elevation is the variable under test.&quot;&quot;&quot;</span>
+    <span class="s">&quot;&quot;&quot;Shared staging; sun_elevation is the only thing that differs per panel.
+
+    The sky is the only light: its sun disc is the key (hard shadow from
+    the gnomon) and its dome is the fill. No studio lights, so a
+    sun_elevation that did not take would render two identical panels.
+    &quot;&quot;&quot;</span>
     sky.sun_elevation = elevation
-    sky.sun_rotation = math.radians(-<span class="n">45.0</span>)
+    sky.sun_rotation = _sun_rotation_for_shadow(SHADOW_AZIMUTH)
     sky.sun_intensity = <span class="n">1.0</span>
-    sky.sun_disc = <span class="k">False</span>
-    sky.ozone_density = <span class="n">5.0</span>
+    sky.sun_disc = <span class="k">True</span>  <span class="c"># the disc is the key light; it stays off-frame</span>
     sky.air_density = <span class="n">1.0</span>
+    sky.ozone_density = <span class="n">1.0</span>
     <span class="k">if</span> bpy.app.version &gt;= (<span class="n">5</span>, <span class="n">0</span>, <span class="n">0</span>):
-        sky.aerosol_density = <span class="n">0.45</span>
+        sky.aerosol_density = <span class="n">1.0</span>
     <span class="k">else</span>:
-        sky.dust_density = <span class="n">0.45</span>
-    bg = world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>]
-    bg.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = <span class="n">0.14</span>
+        sky.dust_density = <span class="n">1.0</span>
+    world.node_tree.nodes[<span class="s">&quot;Background&quot;</span>].inputs[<span class="s">&quot;Strength&quot;</span>].default_value = STILL_STRENGTH
     sc.world = world
 
-    <span class="c"># Remove prior still lights / cams from earlier calls</span>
-    <span class="k">for</span> ob <span class="k">in</span> list(sc.objects):
-        <span class="k">if</span> ob.name.startswith((<span class="s">&quot;Key&quot;</span>, <span class="s">&quot;Fill&quot;</span>, <span class="s">&quot;Rim&quot;</span>, <span class="s">&quot;Cam&quot;</span>, <span class="s">&quot;Aim&quot;</span>, <span class="s">&quot;ProbeCam&quot;</span>, <span class="s">&quot;Label&quot;</span>)):
-            bpy.data.objects.remove(ob, do_unlink=<span class="k">True</span>)
-    <span class="k">for</span> cam <span class="k">in</span> list(bpy.data.cameras):
-        <span class="k">if</span> cam.users == <span class="n">0</span>:
-            bpy.data.cameras.remove(cam)
-    <span class="k">for</span> ld <span class="k">in</span> list(bpy.data.lights):
-        <span class="k">if</span> ld.users == <span class="n">0</span>:
-            bpy.data.lights.remove(ld)
-
-    <span class="k">def</span> area(name, loc, energy, size, col, rot):
-        ld = bpy.data.lights.new(name, <span class="s">&quot;AREA&quot;</span>)
-        ld.energy = energy
-        ld.size = size
-        ld.color = col
-        ob = bpy.data.objects.new(name, ld)
-        ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) <span class="k">for</span> a <span class="k">in</span> rot)
-        sc.collection.objects.link(ob)
-
-    <span class="c"># The sky is the light under test, so the studio lights only model the</span>
-    <span class="c"># form. At 420 W the key drowned the sky and both panels matched.</span>
-    area(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.0</span>, -<span class="n">3.5</span>, <span class="n">4.0</span>), <span class="n">70.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>), (<span class="n">50</span>, <span class="n">0</span>, -<span class="n">32</span>))
-    area(<span class="s">&quot;Fill&quot;</span>, (<span class="n">3.5</span>, -<span class="n">2.2</span>, <span class="n">1.8</span>), <span class="n">10.0</span>, <span class="n">8.0</span>, (<span class="n">1.0</span>, <span class="n">1.0</span>, <span class="n">1.0</span>), (<span class="n">70</span>, <span class="n">0</span>, <span class="n">42</span>))
-
+    cam = sc.objects.get(<span class="s">&quot;Cam&quot;</span>)
+    <span class="k">if</span> cam <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>:
+        <span class="k">return</span> cam
     aim = bpy.data.objects.new(<span class="s">&quot;Aim&quot;</span>, <span class="k">None</span>)
-    aim.location = (<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.8</span>)
+    aim.location = (<span class="n">0.5</span>, <span class="n">0.0</span>, <span class="n">1.6</span>)
     sc.collection.objects.link(aim)
-
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">40.0</span>
+    cam_data.lens = <span class="n">35.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">2.15</span>, -<span class="n">3.55</span>, <span class="n">1.2</span>)
+    cam.location = (<span class="n">0.42</span>, -<span class="n">4.2</span>, <span class="n">1.0</span>)
     sc.collection.objects.link(cam)
     sc.camera = cam
     tr = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     tr.target = aim
     tr.track_axis = <span class="s">&quot;TRACK_NEGATIVE_Z&quot;</span>
     tr.up_axis = <span class="s">&quot;UP_Y&quot;</span>
+    <span class="k">return</span> cam
 
 
-<span class="k">def</span> _render_panel(sc, path, engine, samples=<span class="n">64</span>):
+<span class="k">def</span> _render_panel(sc, path, engine, samples):
     sc.render.engine = <span class="s">&quot;CYCLES&quot;</span> <span class="k">if</span> engine == <span class="s">&quot;cycles&quot;</span> <span class="k">else</span> eevee_engine_id()
     <span class="k">if</span> engine == <span class="s">&quot;cycles&quot;</span>:
         sc.cycles.device = <span class="s">&quot;CPU&quot;</span>
@@ -758,54 +933,112 @@ <h2>Source</h2>
             sc.eevee.taa_render_samples = <span class="n">64</span>
         <span class="k">except</span> AttributeError:
             <span class="k">pass</span>
-    sc.render.resolution_x = <span class="n">640</span>
-    sc.render.resolution_y = <span class="n">720</span>
+    sc.render.resolution_x = PANEL_W
+    sc.render.resolution_y = PANEL_H
+    sc.render.resolution_percentage = <span class="n">100</span>
+    sc.render.film_transparent = <span class="k">False</span>
     sc.render.image_settings.file_format = <span class="s">&quot;PNG&quot;</span>
+    sc.render.image_settings.color_mode = <span class="s">&quot;RGB&quot;</span>
     sc.render.filepath = path
+    <span class="c"># Standard, not AgX: AgX desaturates the granite and the sky toward</span>
+    <span class="c"># pastel. Standard does not compress, hence the clip gate below.</span>
     sc.view_settings.view_transform = <span class="s">&quot;Standard&quot;</span>
+    sc.view_settings.look = <span class="s">&quot;None&quot;</span>
+    sc.view_settings.exposure = <span class="n">0.0</span>
     bpy.ops.render.render(write_still=<span class="k">True</span>)
 
 
-<span class="k">def</span> _diptych(left_path, right_path, out_path):
-    <span class="s">&quot;&quot;&quot;Pack two 640x720 panels into a 1280x720 gallery still.&quot;&quot;&quot;</span>
-    left = bpy.data.images.load(left_path)
-    right = bpy.data.images.load(right_path)
-    w, h = <span class="n">1280</span>, <span class="n">720</span>
-    canvas = bpy.data.images.new(<span class="s">&quot;Diptych&quot;</span>, width=w, height=h, alpha=<span class="k">False</span>)
-    lp = list(left.pixels)
-    rp = list(right.pixels)
+<span class="k">def</span> _diptych(left_path, right_path):
+    <span class="s">&quot;&quot;&quot;Two PANEL_W x PANEL_H panels side by side with a dark gutter rule.&quot;&quot;&quot;</span>
+    left = bpy.data.images.load(left_path, check_existing=<span class="k">False</span>)
+    right = bpy.data.images.load(right_path, check_existing=<span class="k">False</span>)
+    <span class="k">try</span>:
+        lp = left.pixels[:]
+        rp = right.pixels[:]
+    <span class="k">finally</span>:
+        bpy.data.images.remove(left)
+        bpy.data.images.remove(right)
+    w, h, pw = PANEL_W * <span class="n">2</span>, PANEL_H, PANEL_W
     out = [<span class="n">0.0</span>] * (w * h * <span class="n">4</span>)
-    pw = <span class="n">640</span>
+    row = pw * <span class="n">4</span>
+    <span class="k">for</span> y <span class="k">in</span> range(h):
+        s = y * row
+        d = y * w * <span class="n">4</span>
+        out[d:d + row] = lp[s:s + row]
+        out[d + row:d + <span class="n">2</span> * row] = rp[s:s + row]
+    g0 = pw - GUTTER // <span class="n">2</span>
     <span class="k">for</span> y <span class="k">in</span> range(h):
-        <span class="k">for</span> x <span class="k">in</span> range(pw):
-            si = (y * pw + x) * <span class="n">4</span>
-            di_l = (y * w + x) * <span class="n">4</span>
-            di_r = (y * w + (x + pw)) * <span class="n">4</span>
-            out[di_l:di_l + <span class="n">4</span>] = lp[si:si + <span class="n">4</span>]
-            out[di_r:di_r + <span class="n">4</span>] = rp[si:si + <span class="n">4</span>]
-    canvas.pixels = out
-    canvas.filepath_raw = out_path
-    canvas.file_format = <span class="s">&quot;PNG&quot;</span>
-    canvas.save()
-    bpy.data.images.remove(left)
-    bpy.data.images.remove(right)
-    bpy.data.images.remove(canvas)
-
-
-<span class="k">def</span> render_still(sc, world, sky, path, engine):
-    <span class="s">&quot;&quot;&quot;Gallery still: low vs high sun_elevation diptych — the contract at a glance.&quot;&quot;&quot;</span>
+        <span class="k">for</span> x <span class="k">in</span> range(g0, g0 + GUTTER):
+            i = (y * w + x) * <span class="n">4</span>
+            out[i:i + <span class="n">4</span>] = (*GUTTER_RGB, <span class="n">1.0</span>)
+    <span class="k">return</span> w, h, out, lp, rp
+
+
+<span class="k">def</span> clip_fraction(pixels):
+    <span class="s">&quot;&quot;&quot;Fraction of pixels with any RGB channel at 8-bit full scale.&quot;&quot;&quot;</span>
+    n = len(pixels) // <span class="n">4</span>
+    hot = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">0</span>, len(pixels), <span class="n">4</span>):
+        <span class="k">if</span> max(pixels[i], pixels[i + <span class="n">1</span>], pixels[i + <span class="n">2</span>]) &gt;= CLIP_LEVEL:
+            hot += <span class="n">1</span>
+    <span class="k">return</span> hot / max(n, <span class="n">1</span>)
+
+
+<span class="k">def</span> mean_luma(pixels):
+    n = len(pixels) // <span class="n">4</span>
+    acc = <span class="n">0.0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(<span class="n">0</span>, len(pixels), <span class="n">4</span>):
+        acc += <span class="n">0.299</span> * pixels[i] + <span class="n">0.587</span> * pixels[i + <span class="n">1</span>] + <span class="n">0.114</span> * pixels[i + <span class="n">2</span>]
+    <span class="k">return</span> acc / max(n, <span class="n">1</span>)
+
+
+<span class="k">def</span> render_still(sc, world, sky, path, engine, hero, stage):
+    <span class="s">&quot;&quot;&quot;Gallery still: 8 deg | 55 deg diptych of the gnomon under the sky.
+
+    Returns an exit code: 0, 10 (framing), 12 (clipped highlights), 9 (no file).
+    &quot;&quot;&quot;</span>
+    <span class="k">import</span> gallery_framing
+
+    cam = _stage_for_still(sc, world, sky, ELEV_LOW)
+    sc.render.resolution_x, sc.render.resolution_y = PANEL_W, PANEL_H
+    sc.render.resolution_percentage = <span class="n">100</span>
+    <span class="c"># Each panel is its own frame: the gnomon must fill it and clear its edges.</span>
+    code = gallery_framing.check_framing(sc, cam, hero=hero, elements=hero, stage=stage)
+    <span class="k">if</span> code:
+        <span class="k">return</span> code
+
     tmp = tempfile.mkdtemp(prefix=<span class="s">&quot;sky_still_&quot;</span>)
     <span class="k">try</span>:
         left = os.path.join(tmp, <span class="s">&quot;low.png&quot;</span>)
         right = os.path.join(tmp, <span class="s">&quot;high.png&quot;</span>)
-        _stage_for_still(sc, world, sky, ELEV_LOW)
-        _render_panel(sc, left, engine, samples=<span class="n">72</span>)
+        _render_panel(sc, left, engine, samples=STILL_SAMPLES)
         _stage_for_still(sc, world, sky, ELEV_HIGH)
-        _render_panel(sc, right, engine, samples=<span class="n">72</span>)
-        _diptych(left, right, path)
+        _render_panel(sc, right, engine, samples=STILL_SAMPLES)
+        w, h, px, left_px, right_px = _diptych(left, right)
     <span class="k">finally</span>:
         shutil.rmtree(tmp, ignore_errors=<span class="k">True</span>)
-    <span class="k">return</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span>
+
+    <span class="k">for</span> label, p <span class="k">in</span> ((<span class="s">&quot;8deg&quot;</span>, left_px), (<span class="s">&quot;55deg&quot;</span>, right_px)):
+        print(<span class="s">f&quot;</span><span class="s">panel </span>{label}<span class="s">: mean_luma=</span>{mean_luma(p):<span class="s">.3f</span>}<span class="s"> clip=</span>{clip_fraction(p):<span class="s">.6f</span>}<span class="s">&quot;</span>)
+    clipped = clip_fraction(px)
+    print(<span class="s">f&quot;</span><span class="s">clip_fraction=</span>{clipped:<span class="s">.6f</span>}<span class="s"> (gate&lt;=</span>{CLIP_MAX_FRACTION}<span class="s">) strength=</span>{STILL_STRENGTH}<span class="s">&quot;</span>)
+    <span class="k">if</span> clipped &gt; CLIP_MAX_FRACTION:
+        print(
+            <span class="s">f&quot;</span><span class="s">ERROR: </span>{clipped:<span class="s">.4%</span>}<span class="s"> of the still clips to white under Standard — </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span><span class="s">lower the sky Background Strength</span><span class="s">&quot;</span>,
+            file=sys.stderr,
+        )
+        <span class="k">return</span> EXIT_CLIPPED
+
+    canvas = bpy.data.images.new(<span class="s">&quot;Diptych&quot;</span>, width=w, height=h, alpha=<span class="k">False</span>)
+    <span class="k">try</span>:
+        canvas.pixels = px
+        canvas.filepath_raw = path
+        canvas.file_format = <span class="s">&quot;PNG&quot;</span>
+        canvas.save()
+    <span class="k">finally</span>:
+        bpy.data.images.remove(canvas)
+    <span class="k">return</span> <span class="n">0</span> <span class="k">if</span> os.path.exists(path) <span class="k">and</span> os.path.getsize(path) &gt; <span class="n">0</span> <span class="k">else</span> <span class="n">9</span>
 
 
 <span class="k">def</span> build_scene():
@@ -813,9 +1046,10 @@ <h2>Source</h2>
     sc = bpy.context.scene
     world, sky, bg = build_sky_world(ELEV_LOW)
     sc.world = world
-    build_floor(sc)
-    build_ceramic(sc)
-    <span class="k">return</span> sc, world, sky, bg
+    ground, plaza = build_ground(sc)
+    hero, meridian = build_gnomon(sc)
+    stage = [ground, plaza, meridian]
+    <span class="k">return</span> sc, world, sky, bg, hero, stage
 
 
 <span class="k">def</span> main():
@@ -836,15 +1070,19 @@ <h2>Source</h2>
     args = p.parse_args(argv)
 
     print(<span class="s">f&quot;</span><span class="s">binary version: </span>{bpy.app.version}<span class="s"> (</span>{bpy.app.version_string}<span class="s">)</span><span class="s">&quot;</span>)
-    sc, world, sky, bg = build_scene()
+    sc, world, sky, bg, hero, stage = build_scene()
     code = check(sc, world, sky, bg, unlink_sky=args.unlink_sky)
     <span class="k">if</span> code:
         <span class="k">return</span> code
 
     <span class="k">if</span> args.output:
-        <span class="k">if</span> <span class="k">not</span> render_still(sc, world, sky, os.path.abspath(args.output), args.engine):
+        code = render_still(
+            sc, world, sky, os.path.abspath(args.output), args.engine, hero, stage,
+        )
+        <span class="k">if</span> code == <span class="n">9</span>:
             print(<span class="s">&quot;ERROR: render produced no file&quot;</span>, file=sys.stderr)
-            <span class="k">return</span> <span class="n">9</span>
+        <span class="k">if</span> code:
+            <span class="k">return</span> code
         print(<span class="s">f&quot;</span><span class="s">rendered still </span>{args.output}<span class="s">&quot;</span>)
 
     print(<span class="s">&quot;sky-texture-sun-elevation OK&quot;</span>)
@@ -865,7 +1103,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/sky-texture-sun-elevation-hero.webp" alt="Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right." />
+    <img src="../assets/sky-texture-sun-elevation-hero.webp" alt="A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/gallery.json b/examples/gallery.json
index 3ee0006a..7d2f87b8 100644
--- a/examples/gallery.json
+++ b/examples/gallery.json
@@ -460,7 +460,7 @@
       "name": "sky-texture-sun-elevation",
       "dir": "examples/sky-texture-sun-elevation",
       "teaches": "World ShaderNodeTexSky driving Background Color — the sky contract across 4.5 LTS and 5.1. sky_type is NISHITA on 4.5 and MULTIPLE_SCATTERING on 5.1 (NISHITA gone); dust_density exists only on 4.5 (aerosol_density on 5.1). Two tiny Cycles OPEN_EXR zenith probes prove sun_elevation 8 deg to 55 deg brightens zenith (rise 2.25x on 5.1.2, 1.50x on 4.5.11, gate >= 1.25).",
-      "alt": "Split view of a pale glazed jar under a procedural sky: dim twilight blue at sun elevation 8 degrees on the left, bright daylight at 55 degrees on the right.",
+      "alt": "A red-granite obelisk on a paved plaza lit only by the sky: navy dusk with an orange horizon glow at sun elevation 8 degrees, bright blue midday and a short shadow at 55 degrees.",
       "witnessesFix": "AI code still assigns sky_type='NISHITA' and dust_density on 5.1 — both are wrong (NISHITA removed; dust_density is AttributeError; use MULTIPLE_SCATTERING + aerosol_density). A near-black Background Strength alone is not a sky: Sky must link into Background Color. Elevation that does not brighten zenith fails the rise gate.",
       "hero": "docs/gallery/assets/sky-texture-sun-elevation-hero.webp",
       "preview": "examples/sky-texture-sun-elevation/preview.webp",
diff --git a/examples/gallery_framing.py b/examples/gallery_framing.py
index 2aca7162..ab38b4a0 100644
--- a/examples/gallery_framing.py
+++ b/examples/gallery_framing.py
@@ -65,9 +65,9 @@
 the scene the still actually renders from. Multi-scene examples (e.g.
 vse-cut-list, whose gallery still renders from a dedicated ``Bay`` scene
 while ``bpy.context.scene`` is the cut-list scene) must pass that scene
-and its camera explicitly. Examples whose subject IS the world or the
-atmosphere (sky-texture-sun-elevation) have no renderable hero for the
-matte to isolate — they do not call this helper.
+and its camera explicitly. World/sky contracts still stage a renderable
+hero for the matte: sky-texture-sun-elevation measures its gnomon obelisk
+in each diptych panel, with ground and plaza passed as stage.
 """
 import os
 import sys
diff --git a/examples/sky-texture-sun-elevation/README.md b/examples/sky-texture-sun-elevation/README.md
index c2f36591..ac4d92ad 100644
--- a/examples/sky-texture-sun-elevation/README.md
+++ b/examples/sky-texture-sun-elevation/README.md
@@ -2,8 +2,9 @@
 
 A runnable example that builds a World whose Background Color is driven by
 `ShaderNodeTexSky`, then proves `sun_elevation` is load-bearing with two tiny
-Cycles EXR zenith probes — and stages a dual-elevation gallery diptych so the
-contract is visible at thumbnail scale.
+Cycles EXR zenith probes. The gallery still is a sky study: a red-granite
+gnomon obelisk on a paved plaza, lit by nothing but the sky, shown at both
+elevations side by side so the contract reads at thumbnail scale.
 
 **What it witnesses:** the Sky Texture contract AI-generated lighting code most
 often gets wrong across the 4.5 LTS → 5.1 window.
@@ -33,26 +34,40 @@ multiple scattering) but clears the same gate on both binaries.
 
 ## Stage deviation
 
-World carries a Nishita / multiple-scattering Sky Texture instead of the
-default near-black Background — the contract *is* the sky. Gallery still is a
-dual-elevation diptych (8° | 55°) so failure (identical panels) is visible at
-thumbnail scale. Layer 1 still holds: `view_transform='Standard'`, designed
-materials, chosen camera, no helpers in frame.
-
-The jar is pale glaze, and the studio key and fill only model its form
-(70 W and 10 W). With saturated terracotta and a 420 W key, the studio lights
-lit the jar and both panels looked the same: the sky, the thing under test,
-was not what lit it. Now the jar reads dim twilight blue under the 8° sun and
-bright under the 55° sun. Mean luma is about 0.35, above the dark-stage band,
-which is information under this deviation, not a failure.
-
-## Framing deviation
-
-The hero is the sky itself — a world contract, not an object on the stage.
-The silhouette matte can only measure the jar in each 640 px panel (about
-0.37 x / 0.49 y), so an out-of-band number would be a measurement artifact,
-not the composition. The diptych is not wired to `examples/gallery_framing.py`;
-the helper has no `deviation=` flag to report through.
+The World carries a Nishita / multiple-scattering Sky Texture instead of the
+default near-black Background, and there are no studio lights: the contract
+*is* the sky, so the sky's sun disc is the key and its dome is the fill. The
+still is a diptych, 8° | 55°, split by a dark 12 px rule, with one Background
+Strength (0.035) for both panels so `sun_elevation` is the only variable. If
+it did not take, the two panels would render identical.
+
+What reads at a glance: at 8° a deep navy sky with a dusk glow on the left
+horizon, the obelisk's sun face raked orange, the plaza nearly dark and the
+shadow running long out of frame; at 55° a bright blue sky, a sunlit plaza,
+and a short shadow ending on the bronze meridian scale inlaid in the paving.
+The ground runs to the horizon, so there is no void below it.
+
+Layer 1 still holds: `view_transform='Standard'`, designed materials (red
+granite, limestone, bronze, matte gilt, brick-pattern paving), a chosen 35 mm
+camera on a `TRACK_TO` aim, no helpers in frame. Standard does not compress
+highlights, so the render path fails with exit 12 if more than 0.05 % of the
+still clips to white. The committed still has zero clipped pixels. The
+pyramidion is matte gilt rather than metal: a metallic cap Fresnel-glinted
+the 55° sun to pure white at grazing angles, whatever its roughness. Mean
+luma is about 0.20, reported against the calibration set as information
+under this deviation.
+
+The sky's `sun_rotation` is a compass bearing, measured clockwise from +Y.
+The first draft assumed the opposite convention and put the shadow on the
+wrong side. `_sun_rotation_for_shadow` holds the measured mapping.
+
+## Framing
+
+Each 640 × 720 panel is its own frame, and the gnomon is measured in it
+through `examples/gallery_framing.py` (exit 10). Both panels share geometry
+and camera, so one measurement covers both. On 5.2.1 the fill is
+x 0.566 / y 0.794 and the margins are left 0.100, right 0.334,
+bottom 0.044, top 0.161. The ground, plaza and meridian inlay are stage.
 
 ## Run
 
@@ -63,7 +78,7 @@ blender --background --python sky_texture_sun_elevation.py --
 # Falsifier: Sky→Background unlinked. Must exit non-zero (world links).
 blender --background --python sky_texture_sun_elevation.py -- --unlink-sky
 
-# Also render the gallery diptych (Cycles):
+# Also render the gallery diptych (Cycles; framing gate exit 10, clip gate exit 12):
 blender --background --python sky_texture_sun_elevation.py -- --output sky.png
 ```
 
@@ -84,7 +99,10 @@ against it.
 | 7 | High-elevation zenith luma below floor |
 | 8 | Zenith luma did not rise with elevation |
 | 9 | `--output` produced no file |
+| 10 | `--output` framing violation (`gallery_framing`, per panel) |
+| 12 | `--output` still clips to white under Standard (> 0.05 % of pixels) |
 
 The `blender-smoke` workflow runs the check on Blender 5.2 LTS and 4.5 LTS
 (5.1 on the weekly cron, the `needs-5.1` PR label, or manual dispatch).
-Smoke does not pass `--output` or `--unlink-sky`.
+Smoke does not pass `--output` or `--unlink-sky`, so exits 10 and 12 are
+render-path only.
diff --git a/examples/sky-texture-sun-elevation/preview.webp b/examples/sky-texture-sun-elevation/preview.webp
index 98ce251c..b7b3583b 100644
Binary files a/examples/sky-texture-sun-elevation/preview.webp and b/examples/sky-texture-sun-elevation/preview.webp differ
diff --git a/examples/sky-texture-sun-elevation/sky_texture_sun_elevation.py b/examples/sky-texture-sun-elevation/sky_texture_sun_elevation.py
index f3795f12..f979c924 100644
--- a/examples/sky-texture-sun-elevation/sky_texture_sun_elevation.py
+++ b/examples/sky-texture-sun-elevation/sky_texture_sun_elevation.py
@@ -17,13 +17,20 @@
 The sky_type / dust_density version traps are untouched.
 
 By default it runs the correctness check (tiny Cycles CPU renders, no gallery
-still). Pass --output to also render a still:
+still). Pass --output to also render the gallery still: a red-granite gnomon
+obelisk on a paved plaza, lit only by the sky, as an 8 deg | 55 deg diptych.
+The render path gates framing (exit 10, per panel) and clipped highlights
+under Standard (exit 12):
 
     blender --background --python sky_texture_sun_elevation.py --
     blender --background --python sky_texture_sun_elevation.py -- --unlink-sky
     blender --background --python sky_texture_sun_elevation.py -- --output s.png
 """
 import bpy, bmesh, sys, os, math, argparse, tempfile, shutil
+from mathutils import Matrix
+
+# Shared framing gate (render path only); see examples/gallery_framing.py.
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir))
 
 # Radians: low sun vs high sun for the A/B zenith luminance probe
 ELEV_LOW = math.radians(8.0)
@@ -37,6 +44,8 @@
 ZENITH_RISE_MIN = 1.25
 # Absolute floor so a black / unlinked world cannot sneak through
 HIGH_ZENITH_MIN = 0.05
+# Gallery still samples per panel (Cycles CPU, denoised)
+STILL_SAMPLES = 96
 
 
 def eevee_engine_id():
@@ -76,7 +85,7 @@ def build_sky_world(elevation):
     bg = nt.nodes.new("ShaderNodeBackground")
     bg.name = "Background"
     bg.location = (0, 0)
-    # Gallery still restores Strength=1.0 in render_still; probe uses PROBE_STRENGTH
+    # The probe drops this to PROBE_STRENGTH; the still uses STILL_STRENGTH
     bg.inputs["Strength"].default_value = 1.0
 
     out = nt.nodes.new("ShaderNodeOutputWorld")
@@ -123,46 +132,204 @@ def _mesh_obj(sc, name, build_bm, loc, mat, smooth=True):
     return ob
 
 
-def build_ceramic(sc):
-    """A turned jar in pale glaze, so it takes the colour of the sky's light.
+# Gnomon-obelisk proportions (metres). The obelisk is a sundial gnomon: its
+# shadow along the bronze meridian scale is how the still reads elevation.
+STEP_SIZES = ((1.56, 0.16), (1.18, 0.15), (0.82, 0.16))  # (square side, height)
+SHAFT_BASE = 0.40
+SHAFT_TOP = 0.27
+SHAFT_H = 2.35
+PYRAMIDION_H = 0.24
+# Horizontal direction the shadow falls, from +X counter-clockwise. The camera
+# looks roughly along +Y, so -40 deg throws the shadow to the right and toward
+# the lens: the sun sits behind the obelisk's left shoulder, far enough
+# off-axis that its disc stays out of frame and only the dusk glow on the
+# horizon enters the 8 deg panel.
+SHADOW_AZIMUTH = math.radians(-40.0)
+# Obelisk yaw: one visible face turned toward the sun, the other in shade.
+HERO_YAW = math.radians(30.0)
+
+
+def _box(bm, sx, sy, sz, z0=0.0, taper_top=None):
+    """Axis-aligned box, base at z0. taper_top scales the top face (a frustum)."""
+    geom = bmesh.ops.create_cube(bm, size=1.0)
+    verts = [v for v in geom["verts"]]
+    for v in verts:
+        top = v.co.z > 0.0
+        s = taper_top if (top and taper_top is not None) else 1.0
+        v.co.x = v.co.x * sx * s
+        v.co.y = v.co.y * sy * s
+        v.co.z = (v.co.z + 0.5) * sz + z0
+    return verts
+
+
+def _bevel(ob, width, segments=2):
+    mod = ob.modifiers.new("Chamfer", "BEVEL")
+    mod.width = width
+    mod.segments = segments
+    mod.limit_method = "ANGLE"
+    return mod
+
+
+def _stone_material(name, dark, light, rough, scale):
+    """Principled stone with a noise-mixed two-tone base, so it is not a flat fill."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    b = nt.nodes["Principled BSDF"]
+    b.inputs["Roughness"].default_value = rough
+    spec = b.inputs.get("Specular IOR Level") or b.inputs.get("Specular")
+    if spec is not None:
+        spec.default_value = 0.3
+    tc = nt.nodes.new("ShaderNodeTexCoord")
+    noise = nt.nodes.new("ShaderNodeTexNoise")
+    noise.inputs["Scale"].default_value = scale
+    noise.inputs["Detail"].default_value = 6.0
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.35
+    ramp.color_ramp.elements[0].color = (*dark, 1.0)
+    ramp.color_ramp.elements[1].position = 0.70
+    ramp.color_ramp.elements[1].color = (*light, 1.0)
+    nt.links.new(tc.outputs["Object"], noise.inputs["Vector"])
+    nt.links.new(noise.outputs["Fac"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], b.inputs["Base Color"])
+    return mat
 
-    Saturated terracotta looked the same under both skies: the clay's own
-    orange swamped the change in the light, which is the thing on show.
-    """
-    clay = _principled("Clay", (0.80, 0.78, 0.74), rough=0.38, metallic=0.0, specular=0.4)
-    glaze = _principled("Glaze", (0.60, 0.58, 0.55), rough=0.22, metallic=0.0, specular=0.5)
 
-    def body(bm):
-        bmesh.ops.create_cone(
-            bm, cap_ends=True, cap_tris=False,
-            segments=64, radius1=0.62, radius2=0.42, depth=1.35,
-        )
-        # base on the floor (the cone is centred on its depth)
-        bmesh.ops.translate(bm, verts=bm.verts, vec=(0.0, 0.0, 0.675))
+def _paving_material():
+    """Limestone pavers: a Brick texture with a soft mortar, object-space."""
+    mat = bpy.data.materials.new("Paving")
+    mat.use_nodes = True
+    nt = mat.node_tree
+    b = nt.nodes["Principled BSDF"]
+    b.inputs["Roughness"].default_value = 0.82
+    spec = b.inputs.get("Specular IOR Level") or b.inputs.get("Specular")
+    if spec is not None:
+        spec.default_value = 0.2
+    tc = nt.nodes.new("ShaderNodeTexCoord")
+    brick = nt.nodes.new("ShaderNodeTexBrick")
+    brick.inputs["Scale"].default_value = 0.9
+    brick.inputs["Mortar Size"].default_value = 0.012
+    brick.inputs["Color1"].default_value = (0.46, 0.40, 0.32, 1.0)
+    brick.inputs["Color2"].default_value = (0.39, 0.34, 0.27, 1.0)
+    brick.inputs["Mortar"].default_value = (0.16, 0.14, 0.11, 1.0)
+    brick.offset = 0.5
+    brick.squash = 1.0
+    nt.links.new(tc.outputs["Object"], brick.inputs["Vector"])
+    nt.links.new(brick.outputs["Color"], b.inputs["Base Color"])
+    return mat
 
-    vessel = _mesh_obj(sc, "Vessel", body, (0.0, 0.0, 0.0), clay)
-    bev = vessel.modifiers.new("Bev", "BEVEL")
-    bev.width = 0.025
-    bev.segments = 3
-    bev.limit_method = "ANGLE"
 
-    def lid(bm):
+def build_ground(sc):
+    """Paved plaza on open ground that runs to the horizon: no void below it."""
+    ground_mat = _stone_material(
+        "Ground", (0.20, 0.15, 0.10), (0.30, 0.24, 0.17), rough=0.95, scale=0.8,
+    )
+
+    def plane(bm):
+        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=2500.0)
+
+    ground = _mesh_obj(sc, "Ground", plane, (0.0, 0.0, 0.0), ground_mat, smooth=False)
+
+    def disc(bm):
         bmesh.ops.create_cone(
             bm, cap_ends=True, cap_tris=False,
-            segments=48, radius1=0.40, radius2=0.10, depth=0.32,
+            segments=96, radius1=6.5, radius2=6.5, depth=0.04,
         )
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(0.0, 0.0, 0.02))
 
-    knob = _mesh_obj(sc, "Lid", lid, (0.0, 0.0, 1.48), glaze)
-    return vessel, knob
-
+    plaza = _mesh_obj(sc, "Plaza", disc, (0.0, 0.0, 0.0), _paving_material(), smooth=False)
+    return ground, plaza
 
-def build_floor(sc):
-    mat = _principled("Floor", (0.025, 0.026, 0.030), rough=0.85, specular=0.05)
 
-    def grid(bm):
-        bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=60.0)
+def build_gnomon(sc):
+    """Red-granite obelisk on a stepped limestone plinth, matte-gilt pyramidion,
+    and a bronze meridian scale inlaid in the paving along the shadow line.
 
-    return _mesh_obj(sc, "Floor", grid, (0.0, 0.0, 0.0), mat, smooth=False)
+    Returns (hero parts, meridian scale). The hero parts are what the
+    framing matte measures; the scale is ground inlay (stage).
+    """
+    granite = _stone_material(
+        "RedGranite", (0.34, 0.11, 0.07), (0.52, 0.22, 0.15), rough=0.58, scale=38.0,
+    )
+    limestone = _stone_material(
+        "Limestone", (0.40, 0.36, 0.29), (0.50, 0.46, 0.37), rough=0.78, scale=6.0,
+    )
+    # Matte gilt, not metallic: a metallic cap Fresnel-glinted the 55 deg sun
+    # to pure white at grazing, whatever its roughness.
+    gilt = _principled("MatteGilt", (0.42, 0.28, 0.09), rough=0.6, metallic=0.0, specular=0.3)
+    bronze = _principled("Bronze", (0.26, 0.17, 0.10), rough=0.7, metallic=0.85)
+
+    parts = []
+    z = 0.04  # plaza top
+    for i, (side, h) in enumerate(STEP_SIZES):
+        def step(bm, side=side, h=h, z=z):
+            _box(bm, side, side, h, z0=z)
+        ob = _mesh_obj(sc, f"PlinthStep{i + 1}", step, (0.0, 0.0, 0.0), limestone, smooth=False)
+        _bevel(ob, 0.018)
+        parts.append(ob)
+        z += h
+
+    # Dedication plaque on the die face that turns toward the camera.
+    die_side, die_h = STEP_SIZES[-1]
+
+    def plaque(bm, z=z):
+        verts = _box(bm, 0.40, 0.014, 0.085, z0=z - die_h / 2.0 - 0.0425)
+        for v in verts:
+            v.co.y -= die_side / 2.0 + 0.007
+
+    ob = _mesh_obj(sc, "DedicationPlaque", plaque, (0.0, 0.0, 0.0), bronze, smooth=False)
+    _bevel(ob, 0.004, segments=1)
+    parts.append(ob)
+
+    def collar(bm, z=z):
+        _box(bm, SHAFT_BASE + 0.07, SHAFT_BASE + 0.07, 0.07, z0=z)
+
+    ob = _mesh_obj(sc, "BronzeCollar", collar, (0.0, 0.0, 0.0), bronze, smooth=False)
+    _bevel(ob, 0.012)
+    parts.append(ob)
+    z += 0.07
+
+    def shaft(bm, z=z):
+        _box(bm, SHAFT_BASE, SHAFT_BASE, SHAFT_H, z0=z, taper_top=SHAFT_TOP / SHAFT_BASE)
+
+    ob = _mesh_obj(sc, "ObeliskShaft", shaft, (0.0, 0.0, 0.0), granite, smooth=False)
+    _bevel(ob, 0.010)
+    parts.append(ob)
+    z += SHAFT_H
+
+    def pyramidion(bm, z=z):
+        bmesh.ops.create_cone(
+            bm, cap_ends=True, cap_tris=False, segments=4,
+            radius1=SHAFT_TOP / math.sqrt(2.0), radius2=0.0, depth=PYRAMIDION_H,
+        )
+        bmesh.ops.rotate(
+            bm, verts=bm.verts, cent=(0.0, 0.0, 0.0),
+            matrix=Matrix.Rotation(math.radians(45.0), 3, "Z"),
+        )
+        bmesh.ops.translate(bm, verts=bm.verts, vec=(0.0, 0.0, z + PYRAMIDION_H / 2.0))
+
+    ob = _mesh_obj(sc, "Pyramidion", pyramidion, (0.0, 0.0, 0.0), gilt, smooth=False)
+    parts.append(ob)
+    for ob in parts:
+        ob.rotation_euler.z = HERO_YAW
+
+    # Meridian scale: a bronze strip from the plinth edge along the shadow
+    # line, with a cross-tick every metre (one hour-line per tick).
+    def scale_bm(bm):
+        start, end = 0.95, 6.3
+        length = end - start
+        strip = _box(bm, length, 0.07, 0.012, z0=0.035)
+        for v in strip:
+            v.co.x += start + length / 2.0
+        for m in range(1, 7):
+            tick = _box(bm, 0.035, 0.30 if m % 2 == 0 else 0.20, 0.012, z0=0.035)
+            for v in tick:
+                v.co.x += float(m)
+        rot = Matrix.Rotation(SHADOW_AZIMUTH, 3, "Z")
+        bmesh.ops.rotate(bm, verts=bm.verts, cent=(0.0, 0.0, 0.0), matrix=rot)
+
+    meridian = _mesh_obj(sc, "MeridianScale", scale_bm, (0.0, 0.0, 0.0), bronze, smooth=False)
+    return parts, meridian
 
 
 def setup_probe_camera(sc):
@@ -379,65 +546,71 @@ def check(sc, world, sky, bg, unlink_sky=False):
     return 0
 
 
+# Still: one Background Strength for both panels, so the only variable
+# between them is sun_elevation. Tuned so the brightest pixel in either
+# panel stays below clipping under Standard (which does not compress).
+STILL_STRENGTH = 0.035
+PANEL_W, PANEL_H = 640, 720
+GUTTER = 12  # px; a deliberate dark rule between the two panels
+GUTTER_RGB = (0.02, 0.021, 0.025)
+# Clip gate: fraction of pixels allowed at 8-bit full scale in any channel.
+CLIP_LEVEL = 254.5 / 255.0
+CLIP_MAX_FRACTION = 0.0005
+EXIT_CLIPPED = 12
+
+
+def _sun_rotation_for_shadow(shadow_azimuth):
+    """Sky sun_rotation that puts the sun opposite the given shadow azimuth.
+
+    sun_rotation is a compass bearing: measured clockwise from +Y, so the
+    sun's horizontal angle from +X (counter-clockwise) is 90 deg - rotation.
+    Measured, not assumed: the first draft used rotation + 90 deg and threw
+    the shadow to the wrong side of the obelisk.
+    """
+    sun_azimuth = shadow_azimuth + math.pi
+    return math.pi / 2.0 - sun_azimuth
+
+
 def _stage_for_still(sc, world, sky, elevation):
-    """Shared beauty staging; elevation is the variable under test."""
+    """Shared staging; sun_elevation is the only thing that differs per panel.
+
+    The sky is the only light: its sun disc is the key (hard shadow from
+    the gnomon) and its dome is the fill. No studio lights, so a
+    sun_elevation that did not take would render two identical panels.
+    """
     sky.sun_elevation = elevation
-    sky.sun_rotation = math.radians(-45.0)
+    sky.sun_rotation = _sun_rotation_for_shadow(SHADOW_AZIMUTH)
     sky.sun_intensity = 1.0
-    sky.sun_disc = False
-    sky.ozone_density = 5.0
+    sky.sun_disc = True  # the disc is the key light; it stays off-frame
     sky.air_density = 1.0
+    sky.ozone_density = 1.0
     if bpy.app.version >= (5, 0, 0):
-        sky.aerosol_density = 0.45
+        sky.aerosol_density = 1.0
     else:
-        sky.dust_density = 0.45
-    bg = world.node_tree.nodes["Background"]
-    bg.inputs["Strength"].default_value = 0.14
+        sky.dust_density = 1.0
+    world.node_tree.nodes["Background"].inputs["Strength"].default_value = STILL_STRENGTH
     sc.world = world
 
-    # Remove prior still lights / cams from earlier calls
-    for ob in list(sc.objects):
-        if ob.name.startswith(("Key", "Fill", "Rim", "Cam", "Aim", "ProbeCam", "Label")):
-            bpy.data.objects.remove(ob, do_unlink=True)
-    for cam in list(bpy.data.cameras):
-        if cam.users == 0:
-            bpy.data.cameras.remove(cam)
-    for ld in list(bpy.data.lights):
-        if ld.users == 0:
-            bpy.data.lights.remove(ld)
-
-    def area(name, loc, energy, size, col, rot):
-        ld = bpy.data.lights.new(name, "AREA")
-        ld.energy = energy
-        ld.size = size
-        ld.color = col
-        ob = bpy.data.objects.new(name, ld)
-        ob.location = loc
-        ob.rotation_euler = tuple(math.radians(a) for a in rot)
-        sc.collection.objects.link(ob)
-
-    # The sky is the light under test, so the studio lights only model the
-    # form. At 420 W the key drowned the sky and both panels matched.
-    area("Key", (-3.0, -3.5, 4.0), 70.0, 4.0, (1.0, 1.0, 1.0), (50, 0, -32))
-    area("Fill", (3.5, -2.2, 1.8), 10.0, 8.0, (1.0, 1.0, 1.0), (70, 0, 42))
-
+    cam = sc.objects.get("Cam")
+    if cam is not None:
+        return cam
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.8)
+    aim.location = (0.5, 0.0, 1.6)
     sc.collection.objects.link(aim)
-
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 40.0
+    cam_data.lens = 35.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (2.15, -3.55, 1.2)
+    cam.location = (0.42, -4.2, 1.0)
     sc.collection.objects.link(cam)
     sc.camera = cam
     tr = cam.constraints.new("TRACK_TO")
     tr.target = aim
     tr.track_axis = "TRACK_NEGATIVE_Z"
     tr.up_axis = "UP_Y"
+    return cam
 
 
-def _render_panel(sc, path, engine, samples=64):
+def _render_panel(sc, path, engine, samples):
     sc.render.engine = "CYCLES" if engine == "cycles" else eevee_engine_id()
     if engine == "cycles":
         sc.cycles.device = "CPU"
@@ -448,54 +621,112 @@ def _render_panel(sc, path, engine, samples=64):
             sc.eevee.taa_render_samples = 64
         except AttributeError:
             pass
-    sc.render.resolution_x = 640
-    sc.render.resolution_y = 720
+    sc.render.resolution_x = PANEL_W
+    sc.render.resolution_y = PANEL_H
+    sc.render.resolution_percentage = 100
+    sc.render.film_transparent = False
     sc.render.image_settings.file_format = "PNG"
+    sc.render.image_settings.color_mode = "RGB"
     sc.render.filepath = path
+    # Standard, not AgX: AgX desaturates the granite and the sky toward
+    # pastel. Standard does not compress, hence the clip gate below.
     sc.view_settings.view_transform = "Standard"
+    sc.view_settings.look = "None"
+    sc.view_settings.exposure = 0.0
     bpy.ops.render.render(write_still=True)
 
 
-def _diptych(left_path, right_path, out_path):
-    """Pack two 640x720 panels into a 1280x720 gallery still."""
-    left = bpy.data.images.load(left_path)
-    right = bpy.data.images.load(right_path)
-    w, h = 1280, 720
-    canvas = bpy.data.images.new("Diptych", width=w, height=h, alpha=False)
-    lp = list(left.pixels)
-    rp = list(right.pixels)
+def _diptych(left_path, right_path):
+    """Two PANEL_W x PANEL_H panels side by side with a dark gutter rule."""
+    left = bpy.data.images.load(left_path, check_existing=False)
+    right = bpy.data.images.load(right_path, check_existing=False)
+    try:
+        lp = left.pixels[:]
+        rp = right.pixels[:]
+    finally:
+        bpy.data.images.remove(left)
+        bpy.data.images.remove(right)
+    w, h, pw = PANEL_W * 2, PANEL_H, PANEL_W
     out = [0.0] * (w * h * 4)
-    pw = 640
+    row = pw * 4
+    for y in range(h):
+        s = y * row
+        d = y * w * 4
+        out[d:d + row] = lp[s:s + row]
+        out[d + row:d + 2 * row] = rp[s:s + row]
+    g0 = pw - GUTTER // 2
     for y in range(h):
-        for x in range(pw):
-            si = (y * pw + x) * 4
-            di_l = (y * w + x) * 4
-            di_r = (y * w + (x + pw)) * 4
-            out[di_l:di_l + 4] = lp[si:si + 4]
-            out[di_r:di_r + 4] = rp[si:si + 4]
-    canvas.pixels = out
-    canvas.filepath_raw = out_path
-    canvas.file_format = "PNG"
-    canvas.save()
-    bpy.data.images.remove(left)
-    bpy.data.images.remove(right)
-    bpy.data.images.remove(canvas)
-
-
-def render_still(sc, world, sky, path, engine):
-    """Gallery still: low vs high sun_elevation diptych — the contract at a glance."""
+        for x in range(g0, g0 + GUTTER):
+            i = (y * w + x) * 4
+            out[i:i + 4] = (*GUTTER_RGB, 1.0)
+    return w, h, out, lp, rp
+
+
+def clip_fraction(pixels):
+    """Fraction of pixels with any RGB channel at 8-bit full scale."""
+    n = len(pixels) // 4
+    hot = 0
+    for i in range(0, len(pixels), 4):
+        if max(pixels[i], pixels[i + 1], pixels[i + 2]) >= CLIP_LEVEL:
+            hot += 1
+    return hot / max(n, 1)
+
+
+def mean_luma(pixels):
+    n = len(pixels) // 4
+    acc = 0.0
+    for i in range(0, len(pixels), 4):
+        acc += 0.299 * pixels[i] + 0.587 * pixels[i + 1] + 0.114 * pixels[i + 2]
+    return acc / max(n, 1)
+
+
+def render_still(sc, world, sky, path, engine, hero, stage):
+    """Gallery still: 8 deg | 55 deg diptych of the gnomon under the sky.
+
+    Returns an exit code: 0, 10 (framing), 12 (clipped highlights), 9 (no file).
+    """
+    import gallery_framing
+
+    cam = _stage_for_still(sc, world, sky, ELEV_LOW)
+    sc.render.resolution_x, sc.render.resolution_y = PANEL_W, PANEL_H
+    sc.render.resolution_percentage = 100
+    # Each panel is its own frame: the gnomon must fill it and clear its edges.
+    code = gallery_framing.check_framing(sc, cam, hero=hero, elements=hero, stage=stage)
+    if code:
+        return code
+
     tmp = tempfile.mkdtemp(prefix="sky_still_")
     try:
         left = os.path.join(tmp, "low.png")
         right = os.path.join(tmp, "high.png")
-        _stage_for_still(sc, world, sky, ELEV_LOW)
-        _render_panel(sc, left, engine, samples=72)
+        _render_panel(sc, left, engine, samples=STILL_SAMPLES)
         _stage_for_still(sc, world, sky, ELEV_HIGH)
-        _render_panel(sc, right, engine, samples=72)
-        _diptych(left, right, path)
+        _render_panel(sc, right, engine, samples=STILL_SAMPLES)
+        w, h, px, left_px, right_px = _diptych(left, right)
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
-    return os.path.exists(path) and os.path.getsize(path) > 0
+
+    for label, p in (("8deg", left_px), ("55deg", right_px)):
+        print(f"panel {label}: mean_luma={mean_luma(p):.3f} clip={clip_fraction(p):.6f}")
+    clipped = clip_fraction(px)
+    print(f"clip_fraction={clipped:.6f} (gate<={CLIP_MAX_FRACTION}) strength={STILL_STRENGTH}")
+    if clipped > CLIP_MAX_FRACTION:
+        print(
+            f"ERROR: {clipped:.4%} of the still clips to white under Standard — "
+            f"lower the sky Background Strength",
+            file=sys.stderr,
+        )
+        return EXIT_CLIPPED
+
+    canvas = bpy.data.images.new("Diptych", width=w, height=h, alpha=False)
+    try:
+        canvas.pixels = px
+        canvas.filepath_raw = path
+        canvas.file_format = "PNG"
+        canvas.save()
+    finally:
+        bpy.data.images.remove(canvas)
+    return 0 if os.path.exists(path) and os.path.getsize(path) > 0 else 9
 
 
 def build_scene():
@@ -503,9 +734,10 @@ def build_scene():
     sc = bpy.context.scene
     world, sky, bg = build_sky_world(ELEV_LOW)
     sc.world = world
-    build_floor(sc)
-    build_ceramic(sc)
-    return sc, world, sky, bg
+    ground, plaza = build_ground(sc)
+    hero, meridian = build_gnomon(sc)
+    stage = [ground, plaza, meridian]
+    return sc, world, sky, bg, hero, stage
 
 
 def main():
@@ -526,15 +758,19 @@ def main():
     args = p.parse_args(argv)
 
     print(f"binary version: {bpy.app.version} ({bpy.app.version_string})")
-    sc, world, sky, bg = build_scene()
+    sc, world, sky, bg, hero, stage = build_scene()
     code = check(sc, world, sky, bg, unlink_sky=args.unlink_sky)
     if code:
         return code
 
     if args.output:
-        if not render_still(sc, world, sky, os.path.abspath(args.output), args.engine):
+        code = render_still(
+            sc, world, sky, os.path.abspath(args.output), args.engine, hero, stage,
+        )
+        if code == 9:
             print("ERROR: render produced no file", file=sys.stderr)
-            return 9
+        if code:
+            return code
         print(f"rendered still {args.output}")
 
     print("sky-texture-sun-elevation OK")