diff --git a/docs/gallery/assets/hay-bale-hero.webp b/docs/gallery/assets/hay-bale-hero.webp
index 2092fb30..3e87e787 100644
Binary files a/docs/gallery/assets/hay-bale-hero.webp and b/docs/gallery/assets/hay-bale-hero.webp differ
diff --git a/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp b/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp
new file mode 100644
index 00000000..6687b9eb
Binary files /dev/null and b/docs/gallery/contact-sheets/hay-bale-contact-sheet.webp differ
diff --git a/docs/gallery/gn-sdf-remesh/index.html b/docs/gallery/gn-sdf-remesh/index.html
index b5ccd822..e37bc85f 100644
--- a/docs/gallery/gn-sdf-remesh/index.html
+++ b/docs/gallery/gn-sdf-remesh/index.html
@@ -401,7 +401,7 @@ <h2>Source</h2>
     <span class="c"># EEVEE-id inversion witnessed for real: the OTHER era&#x27;s id must be</span>
     <span class="c"># rejected by this build, the helper&#x27;s accepted</span>
     eid = get_eevee_engine_id()
-    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>
+    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>  <span class="c"># engine-id-exempt: the wrong-era id this example asserts is rejected</span>
     <span class="k">try</span>:
         bpy.context.scene.render.engine = wrong
         print(<span class="s">f&quot;</span><span class="s">ERROR: wrong-era EEVEE id &#x27;</span>{wrong}<span class="s">&#x27; was accepted</span><span class="s">&quot;</span>, file=sys.stderr); <span class="k">return</span> <span class="n">5</span>
diff --git a/docs/gallery/hay-bale/index.html b/docs/gallery/hay-bale/index.html
index 1da8cea3..532e35a1 100644
--- a/docs/gallery/hay-bale/index.html
+++ b/docs/gallery/hay-bale/index.html
@@ -4,18 +4,18 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>hay-bale — Showcase — Blender Developer Tools</title>
-  <meta name="description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="description" content="A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract." />
   <link rel="canonical" href="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/hay-bale/" />
   <link rel="icon" href="../../assets/favicon.svg" type="image/svg+xml" />
   <meta name="theme-color" content="#1a1b1e" />
   <meta property="og:type" content="website" />
   <meta property="og:title" content="hay-bale — Showcase — Blender Developer Tools" />
-  <meta property="og:description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta property="og:description" content="A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract." />
   <meta property="og:url" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/hay-bale/" />
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hay-bale-hero.webp" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="hay-bale — Showcase — Blender Developer Tools" />
-  <meta name="twitter:description" content="A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
+  <meta name="twitter:description" content="A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/hay-bale-hero.webp" />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
@@ -246,37 +246,57 @@
   </div>
   <header class="hero">
     <h1>hay-bale</h1>
-    <p>A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
+    <p>A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract.</p>
   </header>
   <main id="main">
     <button class="detail-hero" id="heroZoom" type="button" aria-label="Zoom hay-bale render">
       <img src="../assets/hay-bale-hero.webp" alt="hay-bale render" width="1280" height="720" />
     </button>
     <p class="zoom-hint">Rendered headless by the showcase piece itself — click to zoom.</p>
-    <div class="callout"><span class="tag">witnesses</span> Recomputed: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</div>
+    <div class="callout"><span class="tag">witnesses</span> Recomputed: 2012 tris, two materials with 712 hay and 304 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.921x0.530x0.409 m, zmin 0, hygiene and cross-shell z-fight 0, 5 shells, each belt wrapping under the loaf at zmin 2.6 mm, banded belt seat depth 4.0-16.8 mm over 20/20 stations on both belts, belt mirror error 0, cinch depth 14.2 mm, LOD ratios in band, convex collider 156 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z and --float-belts 16; --slack-belt 18; --skew-belt 19.</div>
     <div class="runline">
       <pre id="runCmd">blender --background --python showcase/hay-bale/hay_bale.py --</pre>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Procedural bound straw bale (cinched pillow loaf, end nap, two square-torus sisal belts with hitch loops) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
+<p>A showcase piece, not an example. Procedural bound straw bale (cinched pillow loaf, end-grain strata, two sisal belts that wrap the loaf&#x27;s own cross-section, tied hitch loops) then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>It asserts <strong>budget conformance</strong> of the generated result. It does not witness an API contract. &quot;It rendered without error&quot; is not a check.</p>
 <p><strong>Composes</strong> skills <code>mesh-editing-and-bmesh</code>, <code>bake-high-to-low</code>, <code>depsgraph-and-evaluated-data</code>, <code>engine-export-presets</code>, and snippets <code>bake_normal_high_to_low.py</code>, <code>setup_bake_target_image.py</code>, <code>lod_chain.py</code> / <code>decimate_to_budget.py</code>, <code>convex_hull_collider.py</code>, <code>export_preset_unity.py</code> (helpers copied, not imported as a package). Hygiene combinatorics match <code>examples/mesh-hygiene-audit</code> (copied, not imported).</p>
-<p>Intended size: 0.90 × 0.48 × 0.38 m core loaf; outer AABB includes cinch bulge and belts.</p>
+<p>Intended size: 0.90 × 0.48 × 0.38 m nominal bale; the loaf measures 0.922 × 0.530 × 0.409 m once the pillow bulge, the belts and the hitch loops are on it.</p>
+<h2>How the belts are built</h2>
+<p>The belt is <strong>not a constant rectangle</strong>. The loaf&#x27;s cross-section at a belt station is rounded, bulged and waisted, so a rectangle stands proud at the middle of each face and is swallowed at the corners — which is exactly what the previous build did, leaving the wrap hanging 2.9–8.3 mm above the floor with a visible notch at the bottom edge.</p>
+<p>Instead the loaf is built, bevelled and <strong>grounded first</strong>, then each belt raycasts the finished loaf at its own station (<code>loaf_profile</code>, <code>BELT_SEGS</code> samples) and follows that profile at a named bite. Where the run passes near the ground it is pressed flush and a little past flush (<code>BELT_PRESS_H</code>, <code>BELT_UNDER_SINK</code>) so the loop closes underneath without breaking the Z=0 plane the bale is grounded on.</p>
+<p>Every closed-form term in the loaf shaping is <strong>even in x</strong>. An odd term (<code>sin(x*24)</code>) put the two belt stations on different surface heights and left the wraps 5.4 mm out of step, which no budget could see.</p>
 <h2>Budgets</h2>
-<p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file.</p>
-<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 750–1100 | 852 / 852 / 852 | | LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.2183 | | Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 294 hay, 132 twine | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.920, 0.517, 0.426) m ± 0.01 | (0.9199, 0.5170, 0.4257) | | Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 | | Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 | | Hay–twine gap | BVH surface &lt; 0.008 m | 0.00007 / 0.00007 / 0.00007 | | Collider tris | ≤ 400 | 78 | | Export | written, size &gt; 0 | 70720 / 70720 / 70712 bytes |</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG. Export byte counts differ by 8 B on 5.2.1 (glTF serializer), not a gated axis.</p>
-<p><code>--skip-decimate</code> skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and exit 9 fires. <code>--lift-z</code> raises the mesh 5 cm so the grounded-zmin hygiene budget fails and exit 16 fires.</p>
+<p>Declared as named constants; every gate <strong>recomputes</strong> from the mesh, materials, UVs, evaluated LOD, collider, or export file. Measurements below are identical on 4.5.11, 5.1.2 and 5.2.1 — construction uses no RNG and no version-dependent operator.</p>
+<p>| Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) | | --- | --- | --- | | Base triangles | 1700–2400 | 2012 on all three | | LOD1 ratio | 0.32–0.62 of base | 0.5000 | | LOD2 ratio | 0.10–0.35 of base | 0.2197 | | Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 712 hay, 304 twine | | UVs | in <code>0..1</code>, AABB overlap ≤ 1e-5 | in range, overlap 0 | | Outer AABB | (0.922, 0.530, 0.409) m ± 0.01 | (0.9208, 0.5295, 0.4087) | | Grounded zmin | within 1e-4 of 0 | 0.000000 | | Hygiene | loose/nonman/zero-area/doubles/n-gons/<strong>z-fight</strong> = 0 | all 0 | | Shell count | exactly 5 (loaf, 2 belts, 2 loops) | 5 | | <strong>Belt wrap zmin</strong> | each belt shell ≤ 0.006 m | 0.002628 both | | <strong>Belt seat depth</strong> | every station in [0.002, 0.020] m | 0.00400..0.01676 over 20/20 stations, both belts | | <strong>Mirror symmetry</strong> | belts and loops matched within 5e-4 m | 0.000000 | | <strong>Cinch depth</strong> | mid-span minus waist in [0.006, 0.020] m | 0.01420 | | Loaf X × Z | (0.922, 0.409) m ± 0.02 | (0.9208, 0.4087) | | Hay–twine gap | BVH surface &lt; 0.008 m | 0.00002 | | Collider tris | ≤ 400 | 156 | | Export | written, size &gt; 0 | 156664 / 156664 / 156656 bytes |</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Export byte counts differ by 8 B on 5.2.1 (glTF serializer), which is not a gated axis; every geometric figure above is identical on all three binaries.</p>
+<p>The export is deleted once its size is measured. Blender sets <code>TMPDIR</code> from its own preference, which resolves to the working directory on a stock portable build, so <code>tempfile.gettempdir()</code> is the repo root under CI and every run used to leave a <code>.glb</code> behind.</p>
+<h3>Why these budgets and not an AABB</h3>
+<p><code>zmin</code> alone cannot see a belt that stops at the bottom edge: the loaf still grounds the box. A single global hay-twine gap cannot see a wrap that hugs one side and gaps the other. A bounding box cannot see two belts 5.4 mm out of step, or a flank with no waist in it. Each of the five budgets in bold above exists because a defect got past everything else and had to be found by looking at a render.</p>
+<p>The z-fight count is taken over <strong>cross-shell</strong> face pairs, not merely over faces that share no vertex: two quads two steps apart on one flat cap share no vertex and are coplanar by construction, and counting those reported 96 pairs, none of them a hazard.</p>
+<h2>Falsifiers</h2>
+<p>Each breaks one stage so a <strong>named</strong> budget fails and the piece exits that code. All six proven on 4.5.11, 5.1.2 and 5.2.1.</p>
+<p>| Flag | Target budget | Exit | | --- | --- | --- | | <code>--skip-decimate</code> | LOD1 ratio band | 9 | | <code>--stray-vert</code> | hygiene: loose vertices | 15 | | <code>--lift-z</code> | grounded AABB zmin | 16 | | <code>--float-belts</code> | per-belt wrap zmin | 16 | | <code>--slack-belt</code> | banded belt seat depth | 18 | | <code>--skew-belt</code> | belt mirror symmetry | 19 |</p>
+<p><code>--stray-vert</code> parks its loose vertex <strong>inside</strong> the bale: above it, the bounding-box budget (exit 8) fired first and the run proved nothing about hygiene. <code>--skew-belt</code> shifts one belt along <strong>X</strong> rather than Z for the same reason — a Z skew landed a belt face coplanar with a loaf face and tripped the z-fight budget (exit 15) instead of its target. <code>--float-belts</code> moves twine only, so the loaf still grounds the AABB and the per-belt gate has to be the thing that fires.</p>
 <h2>Run</h2>
 <pre><code>blender --background --python hay_bale.py --
 blender --background --python hay_bale.py -- --skip-decimate
+blender --background --python hay_bale.py -- --stray-vert
 blender --background --python hay_bale.py -- --lift-z
+blender --background --python hay_bale.py -- --float-belts
+blender --background --python hay_bale.py -- --slack-belt
+blender --background --python hay_bale.py -- --skew-belt
 blender --background --python hay_bale.py -- --output bale.png</code></pre>
-<p>Smoke does not pass <code>--output</code>, <code>--skip-decimate</code>, or <code>--lift-z</code>.</p>
+<p>Smoke does not pass <code>--output</code> or any falsifier flag.</p>
+<h2>Shading</h2>
+<p>Decided per part, not globally. The loaf is <strong>flat</strong>-shaded: straw is a chunky matte mass and the facets read as compressed flakes. Smoothing the whole bale erased every ridge and nap in it and left a featureless pillow that read as a bar of soap. Twine is cord, so the belts and hitch loops stay smooth.</p>
+<p>The low mesh carries the form — bulge, waist, ridges, end strata — and the <strong>high mesh carries the straw</strong>: <code>LOAF_CUTS_HIGH</code> subdivision plus per-band flake offsets, moved onto the low mesh by the bake stage. A low mesh dense enough to model flakes directly would cost thousands of triangles for detail this piece already has a bake for.</p>
+<h2>Known gap</h2>
+<p>At hero scale the piece still reads as a wrapped parcel rather than as straw. The form, the binding and the hygiene are right; the surface is not. The next pass on this piece belongs in the <strong>material and bake</strong> — straw needs directional fibre and colour break-up that a 256 px tangent-space normal off a smooth high mesh cannot deliver — not in more geometry. Recorded here so the next run does not re-litigate the silhouette.</p>
 <h2>Exit codes</h2>
 <p>File-local. <code>9</code> is a valid check code. <code>10</code> is reserved for <code>gallery_framing.check_framing</code> on the <code>--output</code> path.</p>
-<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or hay/twine faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file | | 15 | Hygiene: loose verts/edges, non-manifold, zero-area, doubles, or n-gons | | 16 | Grounded zmin (<code>--lift-z</code> lands here) | | 17 | Hay–twine BVH gap above 8 mm |</p>
+<p>| Code | Meaning | | --- | --- | | 0 | Success | | 1 | Uncaught exception (FATAL wrapper) | | 2 | argparse / usage | | 3 | Mesh did not build / no UV layer | | 4 | Base triangle count outside range | | 5 | Material count ≠ 2 distinct slots, or hay/twine faces missing | | 6 | UVs outside 0..1 | | 7 | UV AABB overlap above tolerance | | 8 | World AABB off declared outer size | | 9 | LOD ratio band (<code>--skip-decimate</code> lands here) | | 10 | Framing gate (render path only) | | 11 | Collider triangle count above ceiling | | 12 | Bake did not finish or image has no data | | 13 | Export file missing or empty | | 14 | <code>--output</code> produced no file | | 15 | Hygiene: loose, non-manifold, zero-area, doubles, n-gons, or cross-shell z-fight (<code>--stray-vert</code>) | | 16 | Grounded: AABB zmin (<code>--lift-z</code>), or a belt that does not wrap under (<code>--float-belts</code>) | | 17 | Shell count, or hay–twine BVH gap above 8 mm | | 18 | Banded belt seat depth (<code>--slack-belt</code>) | | 19 | Belt mirror symmetry (<code>--skew-belt</code>), cinch depth, or loaf real-world size |</p>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -329,19 +349,34 @@ <h2>Source</h2>
 BALE_X = <span class="n">0.90</span>
 BALE_Y = <span class="n">0.48</span>
 BALE_Z = <span class="n">0.38</span>
-TWINE_T = <span class="n">0.012</span>
-TWINE_W = <span class="n">0.028</span>
-TWINE_EMBED = <span class="n">0.003</span>
+TWINE_T = <span class="n">0.016</span>
+TWINE_W = <span class="n">0.024</span>
+TWINE_EMBED = <span class="n">0.004</span>
 BELT_XS = (-<span class="n">0.225</span>, <span class="n">0.225</span>)
-LOAF_CUTS = <span class="n">4</span>
+LOAF_CUTS = <span class="n">8</span>
+<span class="c"># The high mesh carries the straw; the bake moves it onto the low mesh. A</span>
+<span class="c"># low mesh dense enough to model flakes directly would cost thousands of</span>
+<span class="c"># triangles for detail this piece already has a bake stage to deliver.</span>
+LOAF_CUTS_HIGH = <span class="n">20</span>
+FLAKE_W = <span class="n">0.075</span>
+FLAKE_AMP = <span class="n">0.011</span>
 BULGE = <span class="n">0.055</span>
-RIDGE_AMP = <span class="n">0.007</span>
+RIDGE_AMP = <span class="n">0.014</span>
 BBOX_TOL = <span class="n">0.01</span>
 <span class="c"># Fitted after locking geometry. Recomputed from bound_box.</span>
-OUTER_SIZE = (<span class="n">0.920</span>, <span class="n">0.517</span>, <span class="n">0.426</span>)
-
-BASE_TRIS_MIN = <span class="n">750</span>
-BASE_TRIS_MAX = <span class="n">1100</span>
+OUTER_SIZE = (<span class="n">0.922</span>, <span class="n">0.530</span>, <span class="n">0.409</span>)
+
+<span class="c"># The belt follows the loaf&#x27;s own cross-section, sampled by raycast, instead</span>
+<span class="c"># of being a constant rectangle: a rectangle stands proud at the middle of</span>
+<span class="c"># each face and is swallowed at the corners of a bulged loaf.</span>
+BELT_SEGS = <span class="n">20</span>
+CINCH = <span class="n">0.030</span>          <span class="c"># fraction the loaf narrows under each belt</span>
+CINCH_SIGMA = <span class="n">0.075</span>    <span class="c"># metres; how far the waist spreads either side</span>
+NAP_AMP = <span class="n">0.012</span>        <span class="c"># end-grain bite, up from 0.010</span>
+BASE_FLATTEN = <span class="n">0.90</span>    <span class="c"># how much of the pillow bulge gravity removes at z=0</span>
+
+BASE_TRIS_MIN = <span class="n">1700</span>
+BASE_TRIS_MAX = <span class="n">2400</span>
 ZMIN_EPS = <span class="n">1e-4</span>
 DOUBLES_EPS = <span class="n">1e-5</span>
 AREA_EPS = <span class="n">1e-10</span>
@@ -362,6 +397,49 @@ <h2>Source</h2>
 HAY_FACES_MIN = <span class="n">24</span>
 TWINE_FACES_MIN = <span class="n">24</span>
 
+<span class="c"># --- hygiene family, 15..19 -------------------------------------------------</span>
+<span class="c"># Coplanar disjoint face pairs: count only faces that share NO vertex. The</span>
+<span class="c"># triangles of one flat cap are coplanar and close-centred by construction.</span>
+COPLANAR_NORMAL_EPS = <span class="n">1e-4</span>
+COPLANAR_PLANE_EPS = <span class="n">1e-4</span>
+COPLANAR_CENTRE_MAX = <span class="n">0.05</span>
+
+<span class="c"># loaf + 2 belts + 2 hitch loops</span>
+SHELL_COUNT = <span class="n">5</span>
+
+<span class="c"># Each belt is a closed loop that passes *under* the loaf. A belt that stops</span>
+<span class="c"># at the bottom edge leaves a visible notch while the loaf still grounds the</span>
+<span class="c"># AABB, so the AABB zmin gate cannot see it: assert per belt shell.</span>
+BELT_WRAP_ZMAX = <span class="n">0.006</span>
+
+<span class="c"># Banded seat depth, sampled per angular station around the belt rather than</span>
+<span class="c"># as one global figure. A single figure passes while one side visibly gaps.</span>
+SEAT_MIN = <span class="n">0.002</span>
+SEAT_MAX = <span class="n">0.020</span>
+<span class="c"># How far past flush the bottom run is pressed, so the belt stays inside the</span>
+<span class="c"># Z=0 plane the bale is grounded on instead of poking through it.</span>
+BELT_UNDER_SINK = <span class="n">0.0012</span>
+BELT_PRESS_H = <span class="n">0.06</span>
+
+<span class="c"># The two belts are mirror images. The odd ridge term used to put them</span>
+<span class="c"># 5.4 mm out of step, which no budget could see.</span>
+MIRROR_EPS = <span class="n">5e-4</span>
+
+<span class="c"># The cinch is what makes this a *bound* bale rather than a pillow, and it</span>
+<span class="c"># is the one feature no other budget here touches: measured as the loaf&#x27;s</span>
+<span class="c"># half-width at a belt station against its half-width mid-span. Banded, so</span>
+<span class="c"># neither a straight flank nor a strangled one passes.</span>
+CINCH_MIN = <span class="n">0.006</span>
+CINCH_MAX = <span class="n">0.020</span>
+<span class="c"># Loaf length and height against the stated real-world bale. Y is left to</span>
+<span class="c"># the cinch budget above, since the pillow bulge dominates it.</span>
+LOAF_XZ = (<span class="n">0.922</span>, <span class="n">0.409</span>)
+LOAF_XZ_TOL = <span class="n">0.02</span>
+
+FLOAT_BELT_Z = <span class="n">0.02</span>
+SLACK_BELT = <span class="n">0.010</span>
+SKEW_BELT_X = <span class="n">0.004</span>
+
 HAY_IDX = <span class="n">0</span>
 TWINE_IDX = <span class="n">1</span>
 
@@ -434,42 +512,84 @@ <h2>Source</h2>
     <span class="k">return</span> verts
 
 
-<span class="k">def</span> add_square_wrap(bm, x, y_half, z_lo, z_hi, t, w, mat_idx):
-    <span class="s">&quot;&quot;&quot;Closed rectangular belt in YZ, extruded along X. One manifold torus.&quot;&quot;&quot;</span>
-    x0 = x - w * <span class="n">0.5</span>
-    x1 = x + w * <span class="n">0.5</span>
-    inner = (
-        (y_half, z_lo),
-        (y_half, z_hi),
-        (-y_half, z_hi),
-        (-y_half, z_lo),
-    )
-    outer = (
-        (y_half + t, z_lo - t),
-        (y_half + t, z_hi + t),
-        (-y_half - t, z_hi + t),
-        (-y_half - t, z_lo - t),
-    )
+<span class="k">def</span> loaf_profile(bvh, x, centre, segs):
+    <span class="s">&quot;&quot;&quot;Sample the loaf surface at station x, once per angular segment.
+
+    Returns [(y, z)] in the YZ plane. Raycasting the built loaf — rather
+    than evaluating the closed form — means the profile follows the bevel
+    and any later change to the shaping function for free.
+    &quot;&quot;&quot;</span>
+    cy, cz = centre
+    reach = max(BALE_X, BALE_Y, BALE_Z)
+    pts = []
+    <span class="k">for</span> i <span class="k">in</span> range(segs):
+        a = i * (<span class="n">2.0</span> * math.pi / segs)
+        d = Vector((<span class="n">0.0</span>, math.cos(a), math.sin(a)))
+        origin = Vector((x, cy, cz))
+        <span class="c"># Cast inward from well outside: the outermost hit is the surface,</span>
+        <span class="c"># so a concave waist cannot return an interior face.</span>
+        far = origin + d * reach
+        hit, _nrm, _idx, dist = bvh.ray_cast(far, -d, reach * <span class="n">2.0</span>)
+        <span class="k">if</span> hit <span class="k">is</span> <span class="k">None</span>:
+            hit, _nrm, _idx, dist = bvh.ray_cast(origin, d, reach)
+            <span class="k">if</span> hit <span class="k">is</span> <span class="k">None</span>:
+                <span class="k">raise</span> RuntimeError(<span class="s">f&quot;</span><span class="s">loaf profile miss at x=</span>{x}<span class="s"> a=</span>{a}<span class="s">&quot;</span>)
+        pts.append((hit.y, hit.z))
+    <span class="k">return</span> pts
+
+
+<span class="k">def</span> add_belt_wrap(bm, x, profile, centre, t, w, embed, mat_idx):
+    <span class="s">&quot;&quot;&quot;Closed belt following `profile`, extruded along X. One manifold loop.
+
+    The section is chamfered: a hard rectangle reads as masking tape at
+    this scale, and every real edge catches a little light.
+    &quot;&quot;&quot;</span>
+    cy, cz = centre
+    x0, x1 = x - w * <span class="n">0.5</span>, x + w * <span class="n">0.5</span>
+    xm0, xm1 = x - w * <span class="n">0.5</span> + t * <span class="n">0.5</span>, x + w * <span class="n">0.5</span> - t * <span class="n">0.5</span>
+
+    <span class="k">def</span> offset(py, pz, d):
+        vy, vz = py - cy, pz - cz
+        n = math.hypot(vy, vz) <span class="k">or</span> <span class="n">1.0</span>
+        <span class="k">return</span> (py + vy / n * d, pz + vz / n * d)
+
+    <span class="k">def</span> embed_at(_py, pz):
+        <span class="s">&quot;&quot;&quot;Deeper where the run passes near the ground.
+
+        Keyed to the sampled point&#x27;s own height, not to the ray angle: the
+        loaf&#x27;s whole bottom face sits at Z=0, so several stations either
+        side of straight-down land on it, and an angle-keyed press leaves
+        those poking a fraction of a millimetre through the floor.
+
+        The load presses those runs flush and a little past flush, so the
+        belt never breaks the Z=0 plane the bale is grounded on, while the
+        top and side runs still stand proud enough to read.
+        &quot;&quot;&quot;</span>
+        press = max(<span class="n">0.0</span>, <span class="n">1.0</span> - pz / BELT_PRESS_H)
+        <span class="k">return</span> embed + (t + BELT_UNDER_SINK - embed) * press
+
+    <span class="c"># inner surface sits `embed` inside the loaf; outer is `t` further out</span>
+    inner = [offset(py, pz, -embed_at(py, pz)) <span class="k">for</span> py, pz <span class="k">in</span> profile]
+    outer = [offset(py, pz, -embed_at(py, pz) + t) <span class="k">for</span> py, pz <span class="k">in</span> profile]
 
     <span class="k">def</span> ring(xc, pts):
         <span class="k">return</span> [bm.verts.new((xc, p[<span class="n">0</span>], p[<span class="n">1</span>])) <span class="k">for</span> p <span class="k">in</span> pts]
 
-    i0 = ring(x0, inner)
-    o0 = ring(x0, outer)
-    i1 = ring(x1, inner)
-    o1 = ring(x1, outer)
+    i0, i1 = ring(x0, inner), ring(x1, inner)
+    o0, o1 = ring(xm0, outer), ring(xm1, outer)
 
     <span class="k">def</span> quad(a, b, c, d):
-        face = bm.faces.new((a, b, c, d))
-        face.material_index = mat_idx
-        <span class="k">return</span> face
+        f = bm.faces.new((a, b, c, d))
+        f.material_index = mat_idx
+        <span class="k">return</span> f
 
-    <span class="k">for</span> k <span class="k">in</span> range(<span class="n">4</span>):
-        n = (k + <span class="n">1</span>) % <span class="n">4</span>
-        quad(i0[k], i1[k], i1[n], i0[n])
-        quad(o0[k], o0[n], o1[n], o1[k])
-        quad(i0[k], i0[n], o0[n], o0[k])
-        quad(i1[k], o1[k], o1[n], i1[n])
+    n = len(profile)
+    <span class="k">for</span> k <span class="k">in</span> range(n):
+        m = (k + <span class="n">1</span>) % n
+        quad(i0[k], i1[k], i1[m], i0[m])   <span class="c"># inner face, against the loaf</span>
+        quad(o0[k], o0[m], o1[m], o1[k])   <span class="c"># outer face</span>
+        quad(i0[k], i0[m], o0[m], o0[k])   <span class="c"># -X chamfer</span>
+        quad(i1[k], o1[k], o1[m], i1[m])   <span class="c"># +X chamfer</span>
 
 
 <span class="k">def</span> face_area(me, poly):
@@ -515,6 +635,150 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> mesh_shells(me):
+    <span class="s">&quot;&quot;&quot;Vertex-index sets, one per edge-connected component.
+
+    A multi-body prop is not one shell, so Euler characteristic 2 is the
+    wrong contract for it; the shells are what the grounding, mirror and
+    seat budgets below are each measured over.
+    &quot;&quot;&quot;</span>
+    adj = [[] <span class="k">for</span> _ <span class="k">in</span> range(len(me.vertices))]
+    <span class="k">for</span> e <span class="k">in</span> me.edges:
+        a, b = e.vertices
+        adj[a].append(b)
+        adj[b].append(a)
+    seen, shells = set(), []
+    <span class="k">for</span> start <span class="k">in</span> range(len(me.vertices)):
+        <span class="k">if</span> start <span class="k">in</span> seen:
+            <span class="k">continue</span>
+        stack, comp = [start], set()
+        <span class="k">while</span> stack:
+            cur = stack.pop()
+            <span class="k">if</span> cur <span class="k">in</span> comp:
+                <span class="k">continue</span>
+            comp.add(cur)
+            stack.extend(n <span class="k">for</span> n <span class="k">in</span> adj[cur] <span class="k">if</span> n <span class="k">not</span> <span class="k">in</span> comp)
+        seen |= comp
+        shells.append(comp)
+    <span class="k">return</span> shells
+
+
+<span class="k">def</span> shell_stats(me, comp):
+    co = [me.vertices[i].co <span class="k">for</span> i <span class="k">in</span> comp]
+    <span class="k">return</span> {
+        <span class="s">&quot;n&quot;</span>: len(comp),
+        <span class="s">&quot;xmin&quot;</span>: min(c.x <span class="k">for</span> c <span class="k">in</span> co), <span class="s">&quot;xmax&quot;</span>: max(c.x <span class="k">for</span> c <span class="k">in</span> co),
+        <span class="s">&quot;ymin&quot;</span>: min(c.y <span class="k">for</span> c <span class="k">in</span> co), <span class="s">&quot;ymax&quot;</span>: max(c.y <span class="k">for</span> c <span class="k">in</span> co),
+        <span class="s">&quot;zmin&quot;</span>: min(c.z <span class="k">for</span> c <span class="k">in</span> co), <span class="s">&quot;zmax&quot;</span>: max(c.z <span class="k">for</span> c <span class="k">in</span> co),
+    }
+
+
+<span class="k">def</span> coplanar_zfight_pairs(me, shells):
+    <span class="s">&quot;&quot;&quot;Coplanar face pairs from *different shells* — the z-fighting budget.
+
+    Cross-shell, not merely share-no-vertex. Two quads two steps apart on
+    one flat cap share no vertex and are coplanar and close-centred by
+    construction; counting those makes the budget unsatisfiable rather
+    than meaningful (96 pairs on this mesh, none of them a hazard).
+    Z-fighting is two separate bodies landing on one plane, which is
+    exactly a cross-shell pair.
+    &quot;&quot;&quot;</span>
+    owner = {}
+    <span class="k">for</span> si, comp <span class="k">in</span> enumerate(shells):
+        <span class="k">for</span> vi <span class="k">in</span> comp:
+            owner[vi] = si
+    faces = []
+    <span class="k">for</span> p <span class="k">in</span> me.polygons:
+        faces.append((p.normal.copy(), p.center.copy(),
+                      owner.get(p.vertices[<span class="n">0</span>], -<span class="n">1</span>)))
+    hits = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(faces)):
+        ni, ci, si = faces[i]
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(faces)):
+            nj, cj, sj = faces[j]
+            <span class="k">if</span> si == sj:
+                <span class="k">continue</span>
+            <span class="k">if</span> (ci - cj).length &gt; COPLANAR_CENTRE_MAX:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(abs(ni.dot(nj)) - <span class="n">1.0</span>) &gt; COPLANAR_NORMAL_EPS:
+                <span class="k">continue</span>
+            <span class="k">if</span> abs(ni.dot(cj - ci)) &gt; COPLANAR_PLANE_EPS:
+                <span class="k">continue</span>
+            hits += <span class="n">1</span>
+    <span class="k">return</span> hits
+
+
+<span class="k">def</span> belt_seat_depths(me, loaf_comp, belt_comp, station_x, segs):
+    <span class="s">&quot;&quot;&quot;Seat depth per angular station around one belt.
+
+    Banded and per-station, not one global figure: a single number passes
+    while one side of the wrap visibly gaps. The loaf surface is rebuilt
+    from the loaf shell of the *generated* mesh, so nothing here restates
+    a constant the builder set.
+    &quot;&quot;&quot;</span>
+    bm = bmesh.new()
+    <span class="k">try</span>:
+        vmap = {}
+        <span class="k">for</span> i <span class="k">in</span> loaf_comp:
+            vmap[i] = bm.verts.new(me.vertices[i].co)
+        bm.verts.ensure_lookup_table()
+        <span class="k">for</span> p <span class="k">in</span> me.polygons:
+            <span class="k">if</span> all(vi <span class="k">in</span> vmap <span class="k">for</span> vi <span class="k">in</span> p.vertices):
+                <span class="k">try</span>:
+                    bm.faces.new([vmap[vi] <span class="k">for</span> vi <span class="k">in</span> p.vertices])
+                <span class="k">except</span> ValueError:
+                    <span class="k">pass</span>
+        <span class="k">if</span> <span class="k">not</span> bm.faces:
+            <span class="k">return</span> []
+        bvh = BVHTree.FromBMesh(bm)
+    <span class="k">finally</span>:
+        <span class="k">pass</span>
+    zs = [me.vertices[i].co.z <span class="k">for</span> i <span class="k">in</span> loaf_comp]
+    cz = <span class="n">0.5</span> * (min(zs) + max(zs))
+    buckets = {}
+    <span class="k">for</span> i <span class="k">in</span> belt_comp:
+        co = me.vertices[i].co
+        a = math.atan2(co.z - cz, co.y)
+        <span class="c"># Round to the NEAREST station, do not floor into a bin. A station</span>
+        <span class="c"># sitting on a bin boundary put its inner and outer rings in</span>
+        <span class="c"># different bins, and the inner-only bin then reported the wrap as</span>
+        <span class="c"># 12 mm outside the loaf — the outer ring&#x27;s offset, exactly.</span>
+        k = int(round((a + math.pi) / (<span class="n">2.0</span> * math.pi) * segs)) % segs
+        buckets.setdefault(k, []).append(co.copy())
+    reach = max(BALE_X, BALE_Y, BALE_Z) * <span class="n">2.0</span>
+
+    origin = Vector((station_x, <span class="n">0.0</span>, cz))
+
+    <span class="k">def</span> depth(co):
+        <span class="s">&quot;&quot;&quot;How far inside the station&#x27;s own cross-section this point sits.
+
+        Measured along the point&#x27;s own direction from the station axis,
+        NOT by nearest-surface distance. The belt lies in a concave waist,
+        so the nearest loaf face to a belt vertex is often on the bulge
+        shoulder 10 mm away at a neighbouring station, and the wrap then
+        reads as sitting outside a loaf it is in fact hugging.
+        &quot;&quot;&quot;</span>
+        a = math.atan2(co.z - cz, co.y)
+        d = Vector((<span class="n">0.0</span>, math.cos(a), math.sin(a)))
+        hit, _nrm, _idx, _dd = bvh.ray_cast(origin + d * reach, -d, reach * <span class="n">2.0</span>)
+        <span class="k">if</span> hit <span class="k">is</span> <span class="k">None</span>:
+            <span class="k">return</span> <span class="k">None</span>
+        <span class="k">return</span> math.hypot(hit.y, hit.z - cz) - math.hypot(co.y, co.z - cz)
+
+    depths = []
+    <span class="k">for</span> k <span class="k">in</span> sorted(buckets):
+        <span class="c"># Per station, the deepest-seated point of the wrap: the inner</span>
+        <span class="c"># ring. Picking the vertex nearest the belt axis instead looked</span>
+        <span class="c"># equivalent but is not — the rings are unevenly spaced in angle</span>
+        <span class="c"># once the bottom run is pressed in, so some buckets held only</span>
+        <span class="c"># outer-ring vertices and reported the belt 10 mm outside.</span>
+        vals = [d <span class="k">for</span> d <span class="k">in</span> (depth(co) <span class="k">for</span> co <span class="k">in</span> buckets[k]) <span class="k">if</span> d <span class="k">is</span> <span class="k">not</span> <span class="k">None</span>]
+        <span class="k">if</span> vals:
+            depths.append(max(vals))
+    bm.free()
+    <span class="k">return</span> depths
+
+
 <span class="k">def</span> min_mat_distance(me, ia, ib):
     <span class="s">&quot;&quot;&quot;Closest surface distance between two material islands via BVH.
 
@@ -593,7 +857,32 @@ <h2>Source</h2>
             )
 
 
-<span class="k">def</span> _shape_loaf(verts):
+<span class="k">def</span> _cinch(x):
+    <span class="s">&quot;&quot;&quot;How much the loaf narrows at station x, from BELT_XS alone.
+
+    Derived from the belt positions rather than hand-placed, so moving a
+    belt moves its waist with it. A bound bale is defined by this waist;
+    without it the belts lie on a straight flank and nothing reads as tied.
+    &quot;&quot;&quot;</span>
+    <span class="k">return</span> CINCH * sum(
+        math.exp(-((x - bx) / CINCH_SIGMA) ** <span class="n">2</span>) <span class="k">for</span> bx <span class="k">in</span> BELT_XS
+    )
+
+
+<span class="k">def</span> _flake(x):
+    <span class="s">&quot;&quot;&quot;Deterministic per-band offset. A bale is stacked flakes, and the
+    strata are what make it read as straw rather than as a carton.
+
+    Keyed to abs(x) so the pattern is EVEN, like every other term here:
+    an odd term puts the two belt stations on different surface heights.
+    Closed-form hash, no RNG, identical on every binary.
+    &quot;&quot;&quot;</span>
+    band = math.floor(abs(x) / FLAKE_W)
+    h = math.sin(band * <span class="n">12.9898</span>) * <span class="n">43758.5453</span>
+    <span class="k">return</span> (h - math.floor(h)) - <span class="n">0.5</span>
+
+
+<span class="k">def</span> _shape_loaf(verts, flake=<span class="k">False</span>):
     hx = BALE_X * <span class="n">0.5</span>
     hy = BALE_Y * <span class="n">0.5</span>
     hz = BALE_Z * <span class="n">0.5</span>
@@ -603,20 +892,50 @@ <h2>Source</h2>
         nx = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, x / hx))
         ny = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, y / hy))
         nz = max(-<span class="n">1.0</span>, min(<span class="n">1.0</span>, (z - zc) / hz))
-        pillow = <span class="n">1.0</span> + BULGE * (<span class="n">1.0</span> - nx * nx)
+        <span class="c"># Pillow bulge, waisted under every belt station.</span>
+        pillow = (<span class="n">1.0</span> + BULGE * (<span class="n">1.0</span> - nx * nx)) * (<span class="n">1.0</span> - _cinch(x))
+        <span class="c"># Gravity flattens the face the bale rests on: take the bulge out as</span>
+        <span class="c"># z falls to the base, so the bottom stays planar instead of doming</span>
+        <span class="c"># down and being clamped flat afterwards.</span>
+        grounded = <span class="n">1.0</span> - BASE_FLATTEN * max(<span class="n">0.0</span>, -nz) ** <span class="n">2</span>
         v.co.y = y * pillow
-        v.co.z = zc + (z - zc) * pillow
-        <span class="c"># Longitudinal straw ridges on the long faces; closed-form, no RNG.</span>
-        ridge = RIDGE_AMP * math.sin(x * <span class="n">24.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(ny))
-        v.co.y += ridge
-        v.co.z += <span class="n">0.55</span> * RIDGE_AMP * math.sin(x * <span class="n">19.0</span> + <span class="n">0.7</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(nz))
+        v.co.z = zc + (z - zc) * (<span class="n">1.0</span> + (pillow - <span class="n">1.0</span>) * grounded)
+        <span class="c"># Longitudinal straw ridges on the long faces. cos(), not sin(): the</span>
+        <span class="c"># term has to be EVEN in x or the two belt stations sample different</span>
+        <span class="c"># surface heights and the belts end up out of step.</span>
+        <span class="c">#</span>
+        <span class="c"># Faded out under each belt, because the twine compresses the straw</span>
+        <span class="c"># flat where it bites. Without this the ±14 mm ridge swamps the</span>
+        <span class="c"># waist: the cinch measured 2.2 mm and read as a crease rather than</span>
+        <span class="c"># as binding.</span>
+        press = <span class="n">1.0</span> - _cinch(x) / CINCH
+        v.co.y += RIDGE_AMP * math.cos(x * <span class="n">24.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(ny)) * press
+        v.co.z += (
+            <span class="n">0.55</span> * RIDGE_AMP * math.cos(x * <span class="n">19.0</span>) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(nz))
+            * grounded * press
+        )
+        <span class="k">if</span> flake:
+            f = _flake(x) * (<span class="n">0.35</span> + <span class="n">0.65</span> * abs(ny))
+            v.co.y += FLAKE_AMP * f
+            v.co.z += FLAKE_AMP * <span class="n">0.6</span> * _flake(x) * grounded
         <span class="c"># End-grain nap: bite the ±X faces instead of gluing on extra slabs.</span>
+        <span class="c"># Damped to nothing at the face border, because the bevel runs after</span>
+        <span class="c"># this: displacing the border verts turned the four corners into</span>
+        <span class="c"># flared spikes. The ripple is slow (7, not 14) — at 14 it aliased</span>
+        <span class="c"># against the subdivision grid and read as a checkerboard quilt.</span>
         <span class="k">if</span> abs(nx) &gt; <span class="n">0.82</span>:
-            rr = math.hypot(v.co.y / (hy * pillow), (v.co.z - zc) / (hz * pillow))
-            v.co.x += math.copysign(<span class="n">0.010</span> * math.sin(rr * <span class="n">14.0</span>), x)
-
-
-<span class="k">def</span> build_bale_mesh(name, bevel_offset, bevel_segments):
+            <span class="c"># Strata in Z, not rings in r. A cut bale end shows the flake</span>
+            <span class="c"># layers edge-on; a concentric ripple is not what that looks</span>
+            <span class="c"># like, and at BAKE_RES it resolved into a pixelated bullseye</span>
+            <span class="c"># on the hero that read as a printed target.</span>
+            edge = <span class="n">1.0</span> - min(<span class="n">1.0</span>, max(abs(ny), abs(nz))) ** <span class="n">3</span>
+            strata = math.sin((z / BALE_Z) * math.pi * <span class="n">6.0</span>)
+            v.co.x += math.copysign(NAP_AMP * strata * edge, x)
+
+
+<span class="k">def</span> build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
+                    flake=<span class="k">False</span>, slack_belt=<span class="k">False</span>, float_belts=<span class="k">False</span>,
+                    skew_belt=<span class="k">False</span>):
     bm = bmesh.new()
     hay_verts = []
     twine_faces = set()
@@ -632,11 +951,11 @@ <h2>Source</h2>
         bmesh.ops.subdivide_edges(
             bm,
             edges=list({e <span class="k">for</span> v <span class="k">in</span> hay_verts <span class="k">for</span> e <span class="k">in</span> v.link_edges}),
-            cuts=LOAF_CUTS,
+            cuts=cuts,
             use_grid_fill=<span class="k">True</span>,
         )
         hay_verts = [v <span class="k">for</span> v <span class="k">in</span> bm.verts]
-        _shape_loaf(hay_verts)
+        _shape_loaf(hay_verts, flake=flake)
         <span class="k">if</span> bevel_offset &gt; <span class="n">0.0</span>:
             bm.edges.ensure_lookup_table()
             edges = []
@@ -657,59 +976,86 @@ <h2>Source</h2>
                 clamp_overlap=<span class="k">True</span>,
             )
 
-        hay_now = [v <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        <span class="c"># Ground and centre the LOAF first, then hang the belts on the</span>
+        <span class="c"># finished surface. Placing them beforehand and shifting everything</span>
+        <span class="c"># afterwards left each belt a few millimetres off the floor by a</span>
+        <span class="c"># different amount, which is how they ended up out of step.</span>
+        xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        zmin = min(v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts)
+        cx = <span class="n">0.5</span> * (min(xs) + max(xs))
+        cy = <span class="n">0.5</span> * (min(ys) + max(ys))
+        <span class="k">for</span> v <span class="k">in</span> bm.verts:
+            v.co.x -= cx
+            v.co.y -= cy
+            v.co.z -= zmin
+
+        <span class="c"># Sample the loaf&#x27;s own cross-section at each belt station.</span>
+        loaf_bvh = BVHTree.FromBMesh(bm)
+        zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
+        centre = (<span class="n">0.0</span>, <span class="n">0.5</span> * (min(zs) + max(zs)))
+
         before = set(bm.faces)
         <span class="k">for</span> x <span class="k">in</span> BELT_XS:
-            near = [v <span class="k">for</span> v <span class="k">in</span> hay_now <span class="k">if</span> abs(v.co.x - x) &lt;= <span class="n">0.08</span>]
-            <span class="k">if</span> len(near) &lt; <span class="n">8</span>:
-                near = hay_now
-            y_max = max(abs(v.co.y) <span class="k">for</span> v <span class="k">in</span> near)
-            z_min = min(v.co.z <span class="k">for</span> v <span class="k">in</span> near)
-            z_max = max(v.co.z <span class="k">for</span> v <span class="k">in</span> near)
-            <span class="c"># Sit the belt in the ridge troughs so it cinches the peaks.</span>
-            y_half = y_max - RIDGE_AMP - TWINE_EMBED
-            z_lo = z_min + RIDGE_AMP + TWINE_EMBED
-            z_hi = z_max - RIDGE_AMP - TWINE_EMBED
-            add_square_wrap(bm, x, y_half, z_lo, z_hi, TWINE_T, TWINE_W, TWINE_IDX)
+            profile = loaf_profile(loaf_bvh, x, centre, BELT_SEGS)
+            <span class="c"># --slack-belt backs one belt off the loaf so its seat depth</span>
+            <span class="c"># drops below SEAT_MIN on every station of that belt.</span>
+            embed = TWINE_EMBED - (SLACK_BELT <span class="k">if</span> (slack_belt <span class="k">and</span> x &gt; <span class="n">0</span>) <span class="k">else</span> <span class="n">0.0</span>)
+            add_belt_wrap(
+                bm, x, profile, centre, TWINE_T, TWINE_W, embed, TWINE_IDX,
+            )
+            <span class="c"># Hitch loop: the tail of the knot, lying flat on the bale top</span>
+            <span class="c"># alongside its belt. Standing it upright made a wire hoop that</span>
+            <span class="c"># broke the silhouette; laying it in XY reads as tied cord.</span>
+            top_z = max(pz <span class="k">for</span> _py, pz <span class="k">in</span> profile)
             add_rim(
                 bm,
-                (x, <span class="n">0.0</span>, z_hi + TWINE_T),
-                <span class="n">0.014</span>,
-                <span class="n">0.007</span>,
+                <span class="c"># Offset outward from the centre, not along +X: a bare</span>
+                <span class="c"># `x + TWINE_W` put the two loops at -0.201 and +0.249.</span>
+                (x + math.copysign(TWINE_W, x), <span class="n">0.052</span>,
+                 top_z - TWINE_EMBED + TWINE_T * <span class="n">0.45</span>),
+                <span class="n">0.030</span>,
+                <span class="n">0.0062</span>,
                 TWINE_IDX,
-                euler=(math.pi / <span class="n">2.0</span>, <span class="n">0.0</span>, math.pi / <span class="n">2.0</span>),
-                n_major=<span class="n">10</span>,
-                n_minor=<span class="n">5</span>,
+                euler=(<span class="n">0.0</span>, <span class="n">0.0</span>, <span class="n">0.0</span>),
+                n_major=<span class="n">12</span>,
+                n_minor=<span class="n">6</span>,
             )
         twine_faces.update(set(bm.faces) - before)
 
-        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        <span class="k">if</span> float_belts <span class="k">or</span> skew_belt:
+            <span class="c"># Move twine only. The loaf still grounds the AABB, so the</span>
+            <span class="c"># outer-zmin gate stays green and the per-shell gate has to</span>
+            <span class="c"># be the thing that fires.</span>
+            moved = {v <span class="k">for</span> f <span class="k">in</span> twine_faces <span class="k">for</span> v <span class="k">in</span> f.verts}
+            <span class="k">for</span> v <span class="k">in</span> moved:
+                <span class="k">if</span> float_belts:
+                    v.co.z += FLOAT_BELT_Z
+                <span class="k">elif</span> v.co.x &gt; <span class="n">0.0</span>:
+                    <span class="c"># Along X, not Z. A Z skew landed one belt face exactly</span>
+                    <span class="c"># coplanar with a loaf face and tripped the z-fight</span>
+                    <span class="c"># budget (exit 15) instead of the mirror budget it</span>
+                    <span class="c"># targets. An X shift leaves every other budget alone:</span>
+                    <span class="c"># the loaf profile barely changes over 4 mm, so the</span>
+                    <span class="c"># seat band still passes and only the mirror fires.</span>
+                    v.co.x += SKEW_BELT_X
 
-        zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
-        zmin = min(zs)
-        xs = [v.co.x <span class="k">for</span> v <span class="k">in</span> bm.verts]
-        ys = [v.co.y <span class="k">for</span> v <span class="k">in</span> bm.verts]
-        cx = <span class="n">0.5</span> * (min(xs) + max(xs))
-        cy = <span class="n">0.5</span> * (min(ys) + max(ys))
-        <span class="k">for</span> v <span class="k">in</span> bm.verts:
-            v.co.x -= cx
-            v.co.y -= cy
-            v.co.z -= zmin
-            <span class="k">if</span> v.co.z &lt; <span class="n">0.0</span>:
-                v.co.z = <span class="n">0.0</span>
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        <span class="c"># Shading is decided per part, not globally. Smooth-shading the</span>
+        <span class="c"># whole bale erased every ridge and nap in it and left a featureless</span>
+        <span class="c"># pillow that read as a bar of soap. Straw is a chunky matte mass:</span>
+        <span class="c"># the loaf is flat-shaded so its facets read as compressed flakes.</span>
+        <span class="c"># Twine is cord, so the belts and hitch loops stay smooth.</span>
+        live_twine = {f <span class="k">for</span> f <span class="k">in</span> twine_faces <span class="k">if</span> f.is_valid}
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = <span class="k">True</span>
+            face.smooth = face <span class="k">in</span> live_twine
         <span class="k">for</span> edge <span class="k">in</span> bm.edges:
-            edge.smooth = <span class="k">True</span>
-            <span class="k">if</span> edge.is_manifold <span class="k">and</span> len(edge.link_faces) == <span class="n">2</span>:
-                <span class="k">if</span> edge.calc_face_angle() &gt; math.radians(<span class="n">38.0</span>):
-                    edge.smooth = <span class="k">False</span>
-        <span class="k">for</span> f <span class="k">in</span> twine_faces:
-            <span class="k">if</span> f.is_valid:
-                f.material_index = TWINE_IDX
+            edge.smooth = all(f <span class="k">in</span> live_twine <span class="k">for</span> f <span class="k">in</span> edge.link_faces)
+        <span class="k">for</span> f <span class="k">in</span> live_twine:
+            f.material_index = TWINE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -885,10 +1231,19 @@ <h2>Source</h2>
     )
 
 
-<span class="k">def</span> check(skip_decimate, lift_z=<span class="k">False</span>):
+<span class="k">def</span> check(skip_decimate, lift_z=<span class="k">False</span>, stray_vert=<span class="k">False</span>, slack_belt=<span class="k">False</span>,
+          float_belts=<span class="k">False</span>, skew_belt=<span class="k">False</span>):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    low = build_bale_mesh(<span class="s">&quot;BaleLow&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">2</span>)
-    high = build_bale_mesh(<span class="s">&quot;BaleHigh&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">4</span>)
+    low = build_bale_mesh(
+        <span class="s">&quot;BaleLow&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">2</span>,
+        slack_belt=slack_belt, float_belts=float_belts, skew_belt=skew_belt,
+    )
+    <span class="c"># The high mesh is where the straw lives: finer subdivision plus the</span>
+    <span class="c"># flake strata. bake_normal moves that detail onto the low mesh.</span>
+    high = build_bale_mesh(
+        <span class="s">&quot;BaleHigh&quot;</span>, bevel_offset=<span class="n">0.016</span>, bevel_segments=<span class="n">4</span>,
+        cuts=LOAF_CUTS_HIGH, flake=<span class="k">True</span>,
+    )
     hay = principled(
         <span class="s">&quot;BaleHay&quot;</span>,
         (<span class="n">0.66</span>, <span class="n">0.52</span>, <span class="n">0.18</span>, <span class="n">1.0</span>),
@@ -911,6 +1266,16 @@ <h2>Source</h2>
         <span class="k">for</span> v <span class="k">in</span> low.data.vertices:
             v.co.z += LIFT_Z
         low.data.update()
+    <span class="k">if</span> stray_vert:
+        bm = bmesh.new()
+        bm.from_mesh(low.data)
+        <span class="c"># Inside the existing AABB: a stray vertex parked above the bale</span>
+        <span class="c"># blew the bounding-box budget (exit 8) before the hygiene gate</span>
+        <span class="c"># could see it, so it proved nothing about hygiene.</span>
+        bm.verts.new((<span class="n">0.0</span>, <span class="n">0.0</span>, BALE_Z * <span class="n">0.5</span>))
+        bm.to_mesh(low.data)
+        bm.free()
+        low.data.update()
 
     <span class="k">if</span> low.data <span class="k">is</span> <span class="k">None</span> <span class="k">or</span> len(low.data.polygons) &lt; <span class="n">6</span>:
         <span class="k">return</span> fail(<span class="s">&quot;hay bale mesh did not build&quot;</span>, <span class="n">3</span>), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
@@ -955,6 +1320,15 @@ <h2>Source</h2>
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) <span class="k">if</span> os.path.isfile(export_path) <span class="k">else</span> <span class="n">0</span>
+    <span class="c"># Blender sets TMPDIR from its own preference, which resolves to the</span>
+    <span class="c"># working directory on a stock portable build — so gettempdir() is the</span>
+    <span class="c"># repo root under CI and every run left a .glb behind. The budget only</span>
+    <span class="c"># needs the byte count, so drop the file once it is measured.</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        <span class="k">try</span>:
+            os.remove(export_path)
+        <span class="k">except</span> OSError:
+            <span class="k">pass</span>
 
     print(
         <span class="s">f&quot;</span><span class="s">blender=</span>{tuple(bpy.app.version)}<span class="s"> skip_decimate=</span>{skip_decimate}<span class="s">&quot;</span>
@@ -972,7 +1346,89 @@ <h2>Source</h2>
         <span class="s">f&quot;</span><span class="s">outer=</span>{OUTER_SIZE}<span class="s"> zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.4f</span>}<span class="s">&quot;</span>
     )
     hyg = hygiene_audit(low.data)
+    zfight = <span class="n">0</span>  <span class="c"># recomputed below, once the shells are known</span>
     gap = min_mat_distance(low.data, TWINE_IDX, HAY_IDX)
+
+    <span class="c"># --- shells: loaf, two belts, two hitch loops ------------------------</span>
+    shells = mesh_shells(low.data)
+    n_shells = len(shells)
+    zfight = coplanar_zfight_pairs(low.data, shells)
+    stats = [shell_stats(low.data, c) <span class="k">for</span> c <span class="k">in</span> shells]
+    order = sorted(range(len(shells)), key=<span class="k">lambda</span> i: stats[i][<span class="s">&quot;n&quot;</span>])
+    loaf_i = order[-<span class="n">1</span>]
+    loaf_comp = shells[loaf_i]
+    core_x = stats[loaf_i][<span class="s">&quot;xmax&quot;</span>] - stats[loaf_i][<span class="s">&quot;xmin&quot;</span>]
+    core_y = stats[loaf_i][<span class="s">&quot;ymax&quot;</span>] - stats[loaf_i][<span class="s">&quot;ymin&quot;</span>]
+    core_z = stats[loaf_i][<span class="s">&quot;zmax&quot;</span>] - stats[loaf_i][<span class="s">&quot;zmin&quot;</span>]
+
+    <span class="c"># A belt is a non-loaf shell that spans most of the loaf&#x27;s height; a</span>
+    <span class="c"># hitch loop sits on the top run and spans almost none of it.</span>
+    belt_shells, loop_shells = [], []
+    <span class="k">for</span> i, st <span class="k">in</span> enumerate(stats):
+        <span class="k">if</span> i == loaf_i:
+            <span class="k">continue</span>
+        bx = <span class="n">0.5</span> * (st[<span class="s">&quot;xmin&quot;</span>] + st[<span class="s">&quot;xmax&quot;</span>])
+        span = st[<span class="s">&quot;zmax&quot;</span>] - st[<span class="s">&quot;zmin&quot;</span>]
+        (belt_shells <span class="k">if</span> span &gt; core_z * <span class="n">0.5</span> <span class="k">else</span> loop_shells).append((bx, st))
+    belt_shells.sort(key=<span class="k">lambda</span> t: t[<span class="n">0</span>])
+    loop_shells.sort(key=<span class="k">lambda</span> t: t[<span class="n">0</span>])
+
+    <span class="c"># --- mirror symmetry -------------------------------------------------</span>
+    <span class="c"># The two wraps are mirror images. An odd term in the shaping function</span>
+    <span class="c"># used to put them 5.4 mm out of step and no budget could see it.</span>
+    <span class="k">def</span> mirror_error(pairs):
+        <span class="k">if</span> len(pairs) != <span class="n">2</span>:
+            <span class="k">return</span> float(<span class="s">&quot;inf&quot;</span>)
+        (xa, a), (xb, b) = pairs
+        <span class="k">return</span> max(
+            abs(xa + xb),
+            abs(a[<span class="s">&quot;zmin&quot;</span>] - b[<span class="s">&quot;zmin&quot;</span>]),
+            abs(a[<span class="s">&quot;zmax&quot;</span>] - b[<span class="s">&quot;zmax&quot;</span>]),
+            abs((a[<span class="s">&quot;ymax&quot;</span>] - a[<span class="s">&quot;ymin&quot;</span>]) - (b[<span class="s">&quot;ymax&quot;</span>] - b[<span class="s">&quot;ymin&quot;</span>])),
+        )
+
+    mirror_err = max(mirror_error(belt_shells), mirror_error(loop_shells))
+
+    <span class="c"># --- banded seat depth, per angular station --------------------------</span>
+    seat_depths = []
+    <span class="k">for</span> bx, st <span class="k">in</span> belt_shells:
+        comp = next(
+            c <span class="k">for</span> i, c <span class="k">in</span> enumerate(shells)
+            <span class="k">if</span> i != loaf_i <span class="k">and</span> abs(<span class="n">0.5</span> * (stats[i][<span class="s">&quot;xmin&quot;</span>] + stats[i][<span class="s">&quot;xmax&quot;</span>]) - bx) &lt; <span class="n">1e-9</span>
+            <span class="k">and</span> (stats[i][<span class="s">&quot;zmax&quot;</span>] - stats[i][<span class="s">&quot;zmin&quot;</span>]) &gt; core_z * <span class="n">0.5</span>
+        )
+        seat_depths.append((bx, belt_seat_depths(
+            low.data, loaf_comp, comp, bx, BELT_SEGS)))
+
+    <span class="c"># --- cinch depth: the waist the belts pull into the loaf -------------</span>
+    <span class="k">def</span> half_y_at(x0, half_window):
+        ys = [
+            abs(low.data.vertices[i].co.y)
+            <span class="k">for</span> i <span class="k">in</span> loaf_comp
+            <span class="k">if</span> abs(low.data.vertices[i].co.x - x0) &lt;= half_window
+            <span class="k">and</span> <span class="n">0.30</span> * core_z &lt;= low.data.vertices[i].co.z &lt;= <span class="n">0.70</span> * core_z
+        ]
+        <span class="k">return</span> max(ys) <span class="k">if</span> ys <span class="k">else</span> <span class="n">0.0</span>
+
+    win = <span class="n">0.5</span> * (BALE_X / (LOAF_CUTS + <span class="n">1</span>))
+    waist = min(half_y_at(bx, win) <span class="k">for</span> bx <span class="k">in</span> BELT_XS)
+    midspan = half_y_at(<span class="n">0.0</span>, win)
+    cinch_depth = midspan - waist
+
+    print(
+        <span class="s">f&quot;</span><span class="s">measured shells=</span>{n_shells}<span class="s"> loaf=(</span>{core_x:<span class="s">.4f</span>}<span class="s">,</span>{core_y:<span class="s">.4f</span>}<span class="s">,</span>{core_z:<span class="s">.4f</span>}<span class="s">) </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">mirror_err=</span>{mirror_err:<span class="s">.6f</span>}<span class="s"> zfight=</span>{zfight}<span class="s">&quot;</span>
+    )
+    print(
+        <span class="s">f&quot;</span><span class="s">measured cinch waist=</span>{waist:<span class="s">.5f</span>}<span class="s"> midspan=</span>{midspan:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">depth=</span>{cinch_depth:<span class="s">.5f</span>}<span class="s">&quot;</span>
+    )
+    <span class="k">for</span> bx, st <span class="k">in</span> belt_shells:
+        print(<span class="s">f&quot;</span><span class="s">measured belt x=</span>{bx:<span class="s">+.4f</span>}<span class="s"> zmin=</span>{st[<span class="s">&#x27;zmin&#x27;</span>]:<span class="s">.6f</span>}<span class="s">&quot;</span>)
+    <span class="k">for</span> bx, d <span class="k">in</span> seat_depths:
+        <span class="k">if</span> d:
+            print(<span class="s">f&quot;</span><span class="s">measured seat x=</span>{bx:<span class="s">+.4f</span>}<span class="s"> n=</span>{len(d)}<span class="s"> </span><span class="s">&quot;</span>
+                  <span class="s">f&quot;</span><span class="s">min=</span>{min(d):<span class="s">.5f</span>}<span class="s"> max=</span>{max(d):<span class="s">.5f</span>}<span class="s">&quot;</span>)
     print(
         <span class="s">f&quot;</span><span class="s">measured collider_tris=</span>{col_tris}<span class="s"> bake=</span>{bake_result}<span class="s"> </span><span class="s">&quot;</span>
         <span class="s">f&quot;</span><span class="s">bake_has_data=</span>{img.has_data}<span class="s"> export_bytes=</span>{export_size}<span class="s">&quot;</span>
@@ -1054,11 +1510,13 @@ <h2>Source</h2>
         <span class="k">or</span> hyg[<span class="s">&quot;zero_area&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;doubles&quot;</span>]
         <span class="k">or</span> hyg[<span class="s">&quot;ngons&quot;</span>]
+        <span class="k">or</span> zfight
     ):
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">hygiene loose_v=</span>{hyg[<span class="s">&#x27;loose_v&#x27;</span>]}<span class="s"> loose_e=</span>{hyg[<span class="s">&#x27;loose_e&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
             <span class="s">f&quot;</span><span class="s">nonman=</span>{hyg[<span class="s">&#x27;nonman&#x27;</span>]}<span class="s"> zero_area=</span>{hyg[<span class="s">&#x27;zero_area&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
-            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s">&quot;</span>,
+            <span class="s">f&quot;</span><span class="s">doubles=</span>{hyg[<span class="s">&#x27;doubles&#x27;</span>]}<span class="s"> ngons=</span>{hyg[<span class="s">&#x27;ngons&#x27;</span>]}<span class="s"> zfight=</span>{zfight}<span class="s"> </span><span class="s">&quot;</span>
+            <span class="s">&quot;(--stray-vert is the designed fail)&quot;</span>,
             <span class="n">15</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> abs(bb[<span class="n">2</span>]) &gt; ZMIN_EPS:
@@ -1067,11 +1525,60 @@ <h2>Source</h2>
             <span class="s">&quot;(--lift-z is the designed fail)&quot;</span>,
             <span class="n">16</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="c"># The AABB gate above cannot see a belt that stops at the bottom edge:</span>
+    <span class="c"># the loaf still grounds the box. Assert each belt loop passes UNDER</span>
+    <span class="c"># the loaf, which is what a bound bale&#x27;s twine does.</span>
+    <span class="k">for</span> bx, st <span class="k">in</span> belt_shells:
+        <span class="k">if</span> st[<span class="s">&quot;zmin&quot;</span>] &gt; BELT_WRAP_ZMAX:
+            <span class="k">return</span> fail(
+                <span class="s">f&quot;</span><span class="s">belt at x=</span>{bx:<span class="s">+.3f</span>}<span class="s"> zmin </span>{st[<span class="s">&#x27;zmin&#x27;</span>]:<span class="s">.6f</span>}<span class="s"> &gt; </span>{BELT_WRAP_ZMAX}<span class="s"> </span><span class="s">&quot;</span>
+                <span class="s">&quot;— the loop stops at the bottom edge instead of wrapping &quot;</span>
+                <span class="s">&quot;under (--float-belts is the designed fail)&quot;</span>,
+                <span class="n">16</span>,
+            ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> n_shells != SHELL_COUNT:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">shell count </span>{n_shells}<span class="s"> != </span>{SHELL_COUNT}<span class="s">&quot;</span>,
+            <span class="n">17</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">if</span> gap &gt; GAP_MAX:
         <span class="k">return</span> fail(
             <span class="s">f&quot;</span><span class="s">hay-twine gap </span>{gap:<span class="s">.5f</span>}<span class="s"> &gt; </span>{GAP_MAX}<span class="s"> (twine must cinch the loaf)</span><span class="s">&quot;</span>,
             <span class="n">17</span>,
         ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">for</span> bx, depths <span class="k">in</span> seat_depths:
+        <span class="k">if</span> <span class="k">not</span> depths:
+            <span class="k">return</span> fail(<span class="s">f&quot;</span><span class="s">belt at x=</span>{bx:<span class="s">+.3f</span>}<span class="s"> sampled no seat station</span><span class="s">&quot;</span>, <span class="n">18</span>), \
+                <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+        lo, hi = min(depths), max(depths)
+        <span class="k">if</span> lo &lt; SEAT_MIN <span class="k">or</span> hi &gt; SEAT_MAX:
+            <span class="k">return</span> fail(
+                <span class="s">f&quot;</span><span class="s">belt at x=</span>{bx:<span class="s">+.3f</span>}<span class="s"> seat depth </span>{lo:<span class="s">.5f</span>}<span class="s">..</span>{hi:<span class="s">.5f</span>}<span class="s"> outside </span><span class="s">&quot;</span>
+                <span class="s">f&quot;</span><span class="s">[</span>{SEAT_MIN}<span class="s">, </span>{SEAT_MAX}<span class="s">] over </span>{len(depths)}<span class="s"> stations </span><span class="s">&quot;</span>
+                <span class="s">&quot;(--slack-belt is the designed fail)&quot;</span>,
+                <span class="n">18</span>,
+            ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> mirror_err &gt; MIRROR_EPS:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">belts out of step by </span>{mirror_err:<span class="s">.6f</span>}<span class="s"> &gt; </span>{MIRROR_EPS}<span class="s"> — the two </span><span class="s">&quot;</span>
+            <span class="s">&quot;wraps are not mirror images (--skew-belt is the designed fail)&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> <span class="k">not</span> (CINCH_MIN &lt;= cinch_depth &lt;= CINCH_MAX):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">cinch depth </span>{cinch_depth:<span class="s">.5f</span>}<span class="s"> outside [</span>{CINCH_MIN}<span class="s">, </span>{CINCH_MAX}<span class="s">] </span><span class="s">&quot;</span>
+            <span class="s">&quot;— the belts lie on a straight flank, so nothing reads as bound&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
+    <span class="k">if</span> (
+        abs(core_x - LOAF_XZ[<span class="n">0</span>]) &gt; LOAF_XZ_TOL
+        <span class="k">or</span> abs(core_z - LOAF_XZ[<span class="n">1</span>]) &gt; LOAF_XZ_TOL
+    ):
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span><span class="s">loaf (</span>{core_x:<span class="s">.4f</span>}<span class="s"> x </span>{core_z:<span class="s">.4f</span>}<span class="s">) off the stated </span><span class="s">&quot;</span>
+            <span class="s">f&quot;</span>{LOAF_XZ}<span class="s"> m bale</span><span class="s">&quot;</span>,
+            <span class="n">19</span>,
+        ), <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>, <span class="k">None</span>
     <span class="k">return</span> <span class="n">0</span>, low, high, hay, tex, collider
 
 
@@ -1092,7 +1599,10 @@ <h2>Source</h2>
             ob.hide_render = <span class="k">True</span>
             ob.hide_viewport = <span class="k">True</span>
 
-    low.rotation_euler.z = math.radians(-<span class="n">32.0</span>)
+    <span class="c"># A bale is identified by its long ribbed flank and the two belts</span>
+    <span class="c"># crossing it, not by its end. -32 deg swung the end face at the lens</span>
+    <span class="c"># and it dominated the frame.</span>
+    low.rotation_euler.z = math.radians(-<span class="n">20.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -1133,12 +1643,19 @@ <h2>Source</h2>
 
     light(<span class="s">&quot;Key&quot;</span>, (-<span class="n">3.6</span>, -<span class="n">5.0</span>, <span class="n">5.4</span>), <span class="n">660.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.94</span>, <span class="n">0.86</span>), (<span class="n">50</span>, <span class="n">0</span>, -<span class="n">36</span>))
     light(<span class="s">&quot;Fill&quot;</span>, (<span class="n">5.0</span>, -<span class="n">3.4</span>, <span class="n">2.4</span>), <span class="n">46.0</span>, <span class="n">8.0</span>, (<span class="n">0.72</span>, <span class="n">0.82</span>, <span class="n">1.0</span>), (<span class="n">62</span>, <span class="n">0</span>, <span class="n">50</span>))
-    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">2.2</span>, <span class="n">4.0</span>, <span class="n">3.8</span>), <span class="n">600.0</span>, <span class="n">5.5</span>, (<span class="n">1.0</span>, <span class="n">0.70</span>, <span class="n">0.40</span>), (-<span class="n">70</span>, <span class="n">0</span>, <span class="n">198</span>))
+    <span class="c"># Wedge brought in and down with the camera. Pulling the lens back to</span>
+    <span class="c"># 70 mm left the warm pool falling outside the frame, and the first</span>
+    <span class="c"># contact sheet showed a neutral grey stage against a calibration set</span>
+    <span class="c"># that all carry one.</span>
+    light(<span class="s">&quot;Wedge&quot;</span>, (<span class="n">1.5</span>, <span class="n">2.6</span>, <span class="n">2.1</span>), <span class="n">900.0</span>, <span class="n">4.0</span>, (<span class="n">1.0</span>, <span class="n">0.63</span>, <span class="n">0.32</span>), (-<span class="n">62</span>, <span class="n">0</span>, <span class="n">205</span>))
 
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
-    cam_data.lens = <span class="n">50.0</span>
+    <span class="c"># 70 mm from further back rather than 50 mm up close: at 2.1 m a 50 mm</span>
+    <span class="c"># lens put enough perspective on a 0.92 m subject that the near end</span>
+    <span class="c"># read half again as large as the far one.</span>
+    cam_data.lens = <span class="n">70.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">1.26</span>, -<span class="n">1.53</span>, <span class="n">0.88</span>)
+    cam.location = (<span class="n">1.74</span>, -<span class="n">2.28</span>, <span class="n">1.16</span>)
     scene.collection.objects.link(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.15</span>)
@@ -1194,9 +1711,39 @@ <h2>Source</h2>
         action=<span class="s">&quot;store_true&quot;</span>,
         help=<span class="s">&quot;falsification: lift the mesh so zmin fails the grounded budget&quot;</span>,
     )
+    p.add_argument(
+        <span class="s">&quot;--stray-vert&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: add a loose vertex so the hygiene budget fails&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--float-belts&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: lift the belts off the floor so the per-belt &quot;</span>
+             <span class="s">&quot;wrap budget fails while the loaf still grounds the AABB&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--slack-belt&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: back one belt off the loaf so its banded seat &quot;</span>
+             <span class="s">&quot;depth falls below the minimum&quot;</span>,
+    )
+    p.add_argument(
+        <span class="s">&quot;--skew-belt&quot;</span>,
+        action=<span class="s">&quot;store_true&quot;</span>,
+        help=<span class="s">&quot;falsification: raise one belt so the two wraps stop being &quot;</span>
+             <span class="s">&quot;mirror images&quot;</span>,
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, hay, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
+    code, low, _high, hay, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_belts=args.float_belts,
+        slack_belt=args.slack_belt,
+        skew_belt=args.skew_belt,
+    )
     <span class="k">if</span> code:
         <span class="k">return</span> code
     <span class="k">if</span> args.output:
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index 36cdae78..66297919 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -1162,12 +1162,12 @@ <h2><a href="wooden-ladder/">wooden-ladder</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="hay-bale/" aria-label="hay-bale showcase piece detail page">
-          <img src="assets/hay-bale-hero.webp" alt="hay-bale — A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting…" loading="lazy" decoding="async" />
+          <img src="assets/hay-bale-hero.webp" alt="hay-bale — A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="hay-bale/">hay-bale</a></h2>
-          <p class="teaches">A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
-          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.</p>
+          <p class="teaches">A bound hay bale whose twine belts follow the loaf&#x27;s own raycast cross-section, asserting recomputed geometry budgets, not an API contract.</p>
+          <p class="witnesses"><span class="tag">witnesses</span> Recomputed: 2012 tris, two materials with 712 hay and 304 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.921x0.530x0.409 m, zmin 0, hygiene and cross-shell z-fight 0, 5 shells, each belt wrapping under the loaf at zmin 2.6 mm, banded belt seat depth 4.0-16.8 mm over 20/20 stations on both belts, belt mirror error 0, cinch depth 14.2 mm, LOD ratios in band, convex collider 156 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z and --float-belts 16; --slack-belt 18; --skew-belt 19.</p>
           <a class="card-link" href="hay-bale/">View showcase piece <span aria-hidden="true">&rarr;</span></a>
         </div>
       </article>
diff --git a/docs/gallery/iron-cauldron/index.html b/docs/gallery/iron-cauldron/index.html
index 7d7743f2..00773bb2 100644
--- a/docs/gallery/iron-cauldron/index.html
+++ b/docs/gallery/iron-cauldron/index.html
@@ -413,7 +413,14 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> eevee_engine_id():
-    <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">4</span>, <span class="n">2</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span>
+    <span class="s">&quot;&quot;&quot;EEVEE id: &#x27;BLENDER_EEVEE&#x27; on 5.0+, &#x27;BLENDER_EEVEE_NEXT&#x27; on 4.2-4.5.
+
+    Mapping matches examples/swatch-grid.get_eevee_engine_id, which asserts it
+    against the running build (copied, not imported). Inherited the inverted
+    form from showcase/shipping-crate; it returned &#x27;BLENDER_EEVEE_NEXT&#x27; on 5.x,
+    where that id does not exist.
+    &quot;&quot;&quot;</span>
+    <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</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>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
 
 
 <span class="k">def</span> fail(msg, code):
diff --git a/docs/gallery/shipping-crate/index.html b/docs/gallery/shipping-crate/index.html
index 0351ad30..53c6cf80 100644
--- a/docs/gallery/shipping-crate/index.html
+++ b/docs/gallery/shipping-crate/index.html
@@ -399,7 +399,14 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> eevee_engine_id():
-    <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span> <span class="k">if</span> bpy.app.version &gt;= (<span class="n">4</span>, <span class="n">2</span>, <span class="n">0</span>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE&quot;</span>
+    <span class="s">&quot;&quot;&quot;EEVEE id: &#x27;BLENDER_EEVEE&#x27; on 5.0+, &#x27;BLENDER_EEVEE_NEXT&#x27; on 4.2-4.5.
+
+    Mapping matches examples/swatch-grid.get_eevee_engine_id, which asserts it
+    against the running build (copied, not imported). The old form here keyed
+    on &gt;= (4, 2, 0) and so returned &#x27;BLENDER_EEVEE_NEXT&#x27; on 5.x, where that id
+    does not exist — the render path raised TypeError on 5.1 and 5.2.
+    &quot;&quot;&quot;</span>
+    <span class="k">return</span> <span class="s">&quot;BLENDER_EEVEE&quot;</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>) <span class="k">else</span> <span class="s">&quot;BLENDER_EEVEE_NEXT&quot;</span>
 
 
 <span class="k">def</span> fail(msg, code):
diff --git a/docs/gallery/swatch-grid/index.html b/docs/gallery/swatch-grid/index.html
index 96e2ffd0..3eb5e21b 100644
--- a/docs/gallery/swatch-grid/index.html
+++ b/docs/gallery/swatch-grid/index.html
@@ -556,7 +556,7 @@ <h2>Source</h2>
     <span class="c"># Cycles. Witness the inversion for real: the OTHER era&#x27;s id must be rejected</span>
     <span class="c"># by this build, and the helper&#x27;s id must be accepted.</span>
     eid = get_eevee_engine_id()
-    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>
+    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>  <span class="c"># engine-id-exempt: the wrong-era id this example asserts is rejected</span>
     <span class="k">try</span>:
         sc.render.engine = wrong
         print(<span class="s">f&quot;</span><span class="s">ERROR: wrong-era EEVEE id &#x27;</span>{wrong}<span class="s">&#x27; was accepted by this build — </span><span class="s">&quot;</span>
diff --git a/docs/gallery/turntable/index.html b/docs/gallery/turntable/index.html
index 0934eaa8..4f61ab76 100644
--- a/docs/gallery/turntable/index.html
+++ b/docs/gallery/turntable/index.html
@@ -420,7 +420,7 @@ <h2>Source</h2>
     <span class="c"># the EEVEE-id mapping is asserted regardless of whether we render: the</span>
     <span class="c"># OTHER era&#x27;s id must be rejected by this build, the helper&#x27;s accepted</span>
     eid = get_eevee_engine_id()
-    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>
+    wrong = <span class="s">&#x27;BLENDER_EEVEE_NEXT&#x27;</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>) <span class="k">else</span> <span class="s">&#x27;BLENDER_EEVEE&#x27;</span>  <span class="c"># engine-id-exempt: the wrong-era id this example asserts is rejected</span>
     <span class="k">try</span>:
         bpy.context.scene.render.engine = wrong
         print(<span class="s">f&quot;</span><span class="s">ERROR: wrong-era EEVEE id &#x27;</span>{wrong}<span class="s">&#x27; was accepted</span><span class="s">&quot;</span>, file=sys.stderr); <span class="k">return</span> <span class="n">5</span>
diff --git a/examples/exit-pre-sidecar/README.md b/examples/exit-pre-sidecar/README.md
index ea825075..486b3bab 100644
--- a/examples/exit-pre-sidecar/README.md
+++ b/examples/exit-pre-sidecar/README.md
@@ -5,17 +5,69 @@ Witnesses [`drivers-and-app-handlers`](../../skills/drivers-and-app-handlers/SKI
 `main` does not write the file. The host runner asserts it after the
 process exits (`tests/smoke/run_example.py --expect-sidecar`).
 
-5.1+. 4.5 LTS: `AttributeError` — no `exit_pre`. Skip
-(`SMOKE_SKIP: exit_pre requires Blender 5.1+`, exit 77, catalog
-`min_version` 5.1). `--force-run` bypasses the skip so 4.5 fails
-accessing the handler list.
+No gallery still. There is no geometry: the witness is a file that does
+not exist until the process is already gone, and a render would look
+identical whether the handler fired or not.
 
-No gallery still. There is no geometry.
+## The contract
 
-The harness checks **contents** (`sidecar_contains=exit_pre-ok`), not
-existence only. A file written from `main` or `atexit` is red. Several
-falsifiers exit 0 from the script so the **harness** can fail after Blender
-dies.
+`exit_pre` is the only handler in `bpy.app.handlers` that runs during
+interpreter teardown, and it is the difference between a callback that
+runs and one that silently never does. Code that relies on `atexit` for
+this — saving a session log, flushing a render manifest, releasing a
+licence token — is the class of bug this example exists to catch.
+
+| Blender | `hasattr(bpy.app.handlers, "exit_pre")` |
+| --- | --- |
+| 4.5.11 LTS | `False` — `AttributeError` on access |
+| 5.1.2 | `True` |
+| 5.2.1 LTS | `True` |
+
+Re-verified 2026-09-22 against all three binaries. `exit_pre` is also
+the only exit- or quit-related name in `bpy.app.handlers` on the
+versions that have it, so there is no older spelling to fall back to.
+
+API reference:
+[`bpy.app.handlers` (5.2 LTS)](https://docs.blender.org/api/current/bpy.app.handlers.html)
+·
+[`bpy.app.handlers` (4.5 LTS)](https://docs.blender.org/api/4.5/bpy.app.handlers.html)
+— the 4.5 page lists no `exit_pre`, which is the absence this example
+turns into a skip.
+
+## Why 4.5 skips rather than fails
+
+Exiting 77 on 4.5 is **correct by design**, not a gap in coverage. The
+handler does not exist there, so there is no contract to witness and no
+assertion that could meaningfully run. The catalog carries
+`min_version` 5.1 and the runner treats a skip above that floor as a
+FAIL, so the skip cannot quietly spread to a version that should run.
+`tests/smoke/summarize.py` makes a job red if *every* example skipped,
+so a repo-wide skip cannot pass either.
+
+`--force-run` bypasses the skip so 4.5 proves the absence rather than
+assuming it: the run exits 2 on `AttributeError`, and also exits 2 if
+`exit_pre` turns out to exist on a version that should not have it.
+
+## Falsifiers
+
+The harness checks the sidecar's **contents**
+(`sidecar_contains=exit_pre-ok`), not merely that a file appeared.
+Most falsifiers therefore exit **0 from the script** — Blender reports
+success — and the **harness** fails afterwards, which is the only place
+a post-exit contract can be falsified.
+
+| Flag | What it breaks | Script exit | Harness |
+| --- | --- | --- | --- |
+| `--no-handler` | nothing registered, nothing written | 0 | FAIL, no sidecar |
+| `--silent-handler` | `exit_pre` registered but writes nothing | 0 | FAIL, no sidecar |
+| `--wrong-text` | handler writes `nope` | 0 | FAIL, contents mismatch |
+| `--write-in-main` | `from-main` written in `main`, no handler | 0 | FAIL, contents mismatch |
+| `--atexit-instead` | `atexit` writes `atexit-ok` instead of `exit_pre` | 0 | FAIL, contents mismatch |
+| `--force-run` on 4.5 | asserts `exit_pre` is genuinely absent | 2 | n/a |
+
+`--write-in-main` and `--atexit-instead` are the two that matter: both
+produce a file, so an existence-only check would pass them. They are why
+the catalog row carries `sidecar_contains`.
 
 ## Run
 
@@ -28,6 +80,8 @@ python tests/smoke/run_example.py --name exit-pre-sidecar \
   --expect-sidecar /tmp/exit-pre.sidecar --sidecar-contains exit_pre-ok
 ```
 
+Append `-- --wrong-text` (or any flag above) to falsify.
+
 ## Exit codes
 
 Per-script sequential checks. `9` is a valid check code; there is no rule
diff --git a/examples/exit-pre-sidecar/exit_pre_sidecar.py b/examples/exit-pre-sidecar/exit_pre_sidecar.py
index 3fbfac0f..38f7a41d 100644
--- a/examples/exit-pre-sidecar/exit_pre_sidecar.py
+++ b/examples/exit-pre-sidecar/exit_pre_sidecar.py
@@ -6,10 +6,15 @@
 handler writes it. The host runner (``tests/smoke/run_example.py``)
 asserts the file after the process exits.
 
-5.1+. 4.5 LTS has no ``exit_pre`` (AttributeError). Catalog
-``min_version`` 5.0 is wrong — the floor is 5.1. Skip: ``SMOKE_SKIP``.
+5.1+. 4.5 LTS has no ``exit_pre`` (AttributeError), so the catalog
+``min_version`` is 5.1 and the script skips below it (``SMOKE_SKIP``).
 ``--force-run`` bypasses the skip so 4.5 fails accessing ``exit_pre``.
 
+Re-verified 2026-09-22 on 4.5.11 LTS, 5.1.2 and 5.2.1 LTS:
+``hasattr(bpy.app.handlers, "exit_pre")`` is False / True / True, and
+``exit_pre`` is the only exit-related name in ``bpy.app.handlers`` on
+the versions that have it.
+
 No gallery still. There is no geometry.
 
     blender --background --python exit_pre_sidecar.py --
diff --git a/showcase/README.md b/showcase/README.md
index 0706b253..225ebcb1 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -65,6 +65,13 @@ entry in `showcase/gallery.json`, and a rendered still.
   the last one over faces that share **no** vertex: the triangles of one
   flat fan cap are coplanar and close-centred by construction, and
   counting those makes the budget unsatisfiable rather than meaningful.
+  Count the coplanar pairs **cross-shell**, not merely over faces that
+  share no vertex: two quads two steps apart on one flat cap share no
+  vertex and are coplanar and close-centred by construction. Counting
+  those reported 96 pairs on `hay-bale`, none of them a hazard, which is
+  the same unsatisfiable-budget trap in a second disguise. Z-fighting is
+  two separate bodies landing on one plane, and that is a cross-shell
+  pair by definition.
   Multi-body props do **not** require Euler characteristic 2 — that is a
   single-shell contract. Two boxes that share a coplanar face z-fight;
   two that share a vertex weld into one shell. Seat a joint with a named
@@ -100,6 +107,26 @@ entry in `showcase/gallery.json`, and a rendered still.
   hypot-length box rotated about its centroid. The centroid form is
   short of one host and punches through the other. `--short-brace` /
   `--float-spout` (or the piece's equivalent) is the falsifier.
+- **Even shaping terms and mirror symmetry (exit 19).** Where a prop has
+  mirrored members — two belts, two brackets, a pair of feet — every
+  closed-form term in the host's shaping function must be **even** in
+  the mirrored axis. `hay-bale` used `sin(x*24)`, which is odd, so its
+  two belt stations sampled different surface heights and the wraps
+  shipped 5.4 mm out of step; `cos` fixed it exactly. Assert it: pair the
+  mirrored shells and compare their axis positions and extents within a
+  named epsilon. A bounding box cannot see this, and neither can a
+  per-member budget that only ever looks at one member.
+- **Wrappers follow the host's profile, and the host is finished first
+  (exit 16/18).** Build, bevel and **ground the host, then** hang the
+  wrapper on the finished surface by raycasting the host's own
+  cross-section at the wrapper's station. Placing a wrapper against
+  half-built geometry and shifting everything afterwards leaves each one
+  a different distance off the floor. A constant-section rectangle on a
+  rounded host stands proud at the middle of each face and is swallowed
+  at the corners — `hay-bale`'s belts stopped 2.9–8.3 mm above the floor
+  with a visible notch, while the AABB `zmin` gate stayed green because
+  the loaf grounded the box. Assert **per wrapper shell** that the loop
+  passes under the host, not just that something touches Z=0.
 - **Seat conformance (exit 18).** A band, hoop, strap or collar wrapped
   around a host asserts a **banded** seat depth — a minimum so it cannot
   float and a maximum so it cannot sink — sampled per angular segment
@@ -110,6 +137,14 @@ entry in `showcase/gallery.json`, and a rendered still.
   vertices as inner ones the moment the host is out of round, which is
   how a hoop that visibly gapped on one side still passed.   The paired
   falsifier makes the wrapper a true circle on an out-of-round host.
+  Measure the depth **station-locally**, along the vertex's own direction
+  from the station axis — not by nearest-surface distance. A wrapper
+  seated in a concave waist has its nearest host face on the bulge
+  shoulder at a neighbouring station, and the wrap then reads as sitting
+  10 mm outside a host it is in fact hugging. Bin the samples by
+  **rounding** to the nearest station, never by flooring: a station on a
+  bin boundary puts its inner and outer rings in different bins, and the
+  inner-only bin reports the wrapper's outer offset as its seat depth.
 - **Level sole on a raked leg (exit 18).** A raked stile does not sit
   in a world-axis cube. Build the sleeve in the member frame so it
   follows the rake; add the tread after the rake as its own
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 8434cb0b..3914d102 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -308,8 +308,8 @@
     {
       "name": "hay-bale",
       "dir": "showcase/hay-bale",
-      "teaches": "A procedural bound hay bale with a cinched pillow loaf, end nap, and two sisal twine belts through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "witnessesFix": "Recomputed: 852 tris, two materials with 294 hay and 132 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.920×0.517×0.426 m, zmin 0, hygiene 0, hay-twine BVH gap 0.07 mm, LOD ratios in band, convex collider 78 tris, non-empty glTF. --skip-decimate exits 9 on LOD1; --lift-z exits 16 on grounded zmin.",
+      "teaches": "A bound hay bale whose twine belts follow the loaf's own raycast cross-section, asserting recomputed geometry budgets, not an API contract.",
+      "witnessesFix": "Recomputed: 2012 tris, two materials with 712 hay and 304 twine faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.921x0.530x0.409 m, zmin 0, hygiene and cross-shell z-fight 0, 5 shells, each belt wrapping under the loaf at zmin 2.6 mm, banded belt seat depth 4.0-16.8 mm over 20/20 stations on both belts, belt mirror error 0, cinch depth 14.2 mm, LOD ratios in band, convex collider 156 tris, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z and --float-belts 16; --slack-belt 18; --skew-belt 19.",
       "hero": "docs/gallery/assets/hay-bale-hero.webp",
       "preview": "showcase/hay-bale/preview.webp",
       "tags": [
@@ -318,28 +318,28 @@
       ]
     },
     {
-        "name": "crate-stack",
-        "dir": "showcase/crate-stack",
-        "teaches": "A stack of three procedural shipping crates built by one generator called three times with a per-instance seed, carried through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-        "witnessesFix": "Recomputed: 4380 tris, two materials with 216 iron and 2436 timber faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.658×0.524×0.704 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, three ground runners at z=0, both crate-to-crate seats overlapping, each crate's own footprint 0.585×0.425 m measured in its own frame, yaw spread 0.026 rad and plank spread 2.05 mm across instances, LOD ratios in band, convex collider 202 tris, non-empty glTF. --float-stack exits 18 on the seat; --same-seed exits 20 on per-instance variation.",
-        "hero": "docs/gallery/assets/crate-stack-hero.webp",
-        "preview": "showcase/crate-stack/preview.webp",
-        "tags": [
-            "mesh",
-            "export"
-        ]
+      "name": "crate-stack",
+      "dir": "showcase/crate-stack",
+      "teaches": "A stack of three procedural shipping crates built by one generator called three times with a per-instance seed, carried through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 4380 tris, two materials with 216 iron and 2436 timber faces, UVs in 0..1 with zero AABB overlap, outer AABB 0.658×0.524×0.704 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, three ground runners at z=0, both crate-to-crate seats overlapping, each crate's own footprint 0.585×0.425 m measured in its own frame, yaw spread 0.026 rad and plank spread 2.05 mm across instances, LOD ratios in band, convex collider 202 tris, non-empty glTF. --float-stack exits 18 on the seat; --same-seed exits 20 on per-instance variation.",
+      "hero": "docs/gallery/assets/crate-stack-hero.webp",
+      "preview": "showcase/crate-stack/preview.webp",
+      "tags": [
+        "mesh",
+        "export"
+      ]
     },
     {
-        "name": "stone-archway",
-        "dir": "showcase/stone-archway",
-        "teaches": "A procedural masonry archway — coursed piers, projecting imposts, nine voussoirs and a proud keystone — carried through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-        "witnessesFix": "Recomputed: 924 tris, two materials with 182 dressed and 364 ashlar faces re-stamped after the chamfer, UVs in 0..1 with zero AABB overlap, outer AABB 1.644×0.510×2.057 m, clear opening 1.203 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, both piers grounded, the springing joint an overlap, all eight mortar joints at 9.70 mm inside the 6–17 mm band, and every intrados vertex within 0.97 mm of the declared 0.60 m radius over 178°. --off-circle exits 19 on the circle fit; --wide-mortar exits 18 on the joint band.",
-        "hero": "docs/gallery/assets/stone-archway-hero.webp",
-        "preview": "showcase/stone-archway/preview.webp",
-        "tags": [
-            "mesh",
-            "export"
-        ]
+      "name": "stone-archway",
+      "dir": "showcase/stone-archway",
+      "teaches": "A procedural masonry archway — coursed piers, projecting imposts, nine voussoirs and a proud keystone — carried through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
+      "witnessesFix": "Recomputed: 924 tris, two materials with 182 dressed and 364 ashlar faces re-stamped after the chamfer, UVs in 0..1 with zero AABB overlap, outer AABB 1.644×0.510×2.057 m, clear opening 1.203 m, zmin 0, hygiene 0 including zero coplanar disjoint pairs, both piers grounded, the springing joint an overlap, all eight mortar joints at 9.70 mm inside the 6–17 mm band, and every intrados vertex within 0.97 mm of the declared 0.60 m radius over 178°. --off-circle exits 19 on the circle fit; --wide-mortar exits 18 on the joint band.",
+      "hero": "docs/gallery/assets/stone-archway-hero.webp",
+      "preview": "showcase/stone-archway/preview.webp",
+      "tags": [
+        "mesh",
+        "export"
+      ]
     }
   ]
 }
diff --git a/showcase/hay-bale/README.md b/showcase/hay-bale/README.md
index 36ec1a8a..feb9f605 100644
--- a/showcase/hay-bale/README.md
+++ b/showcase/hay-bale/README.md
@@ -1,9 +1,10 @@
 # Hay bale
 
 A showcase piece, not an example. Procedural bound straw bale (cinched
-pillow loaf, end nap, two square-torus sisal belts with hitch loops)
-then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
-bake, LOD chain, convex collider, Unity glTF export.
+pillow loaf, end-grain strata, two sisal belts that wrap the loaf's own
+cross-section, tied hitch loops) then the shipped pipeline: unique-cell
+UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity
+glTF export.
 
 It asserts **budget conformance** of the generated result. It does not
 witness an API contract. "It rendered without error" is not a check.
@@ -16,48 +17,142 @@ witness an API contract. "It rendered without error" is not a check.
 Hygiene combinatorics match `examples/mesh-hygiene-audit` (copied, not
 imported).
 
-Intended size: 0.90 × 0.48 × 0.38 m core loaf; outer AABB includes
-cinch bulge and belts.
+Intended size: 0.90 × 0.48 × 0.38 m nominal bale; the loaf measures
+0.922 × 0.530 × 0.409 m once the pillow bulge, the belts and the hitch
+loops are on it.
+
+## How the belts are built
+
+The belt is **not a constant rectangle**. The loaf's cross-section at a
+belt station is rounded, bulged and waisted, so a rectangle stands proud
+at the middle of each face and is swallowed at the corners — which is
+exactly what the previous build did, leaving the wrap hanging 2.9–8.3 mm
+above the floor with a visible notch at the bottom edge.
+
+Instead the loaf is built, bevelled and **grounded first**, then each
+belt raycasts the finished loaf at its own station (`loaf_profile`,
+`BELT_SEGS` samples) and follows that profile at a named bite. Where the
+run passes near the ground it is pressed flush and a little past flush
+(`BELT_PRESS_H`, `BELT_UNDER_SINK`) so the loop closes underneath
+without breaking the Z=0 plane the bale is grounded on.
+
+Every closed-form term in the loaf shaping is **even in x**. An odd term
+(`sin(x*24)`) put the two belt stations on different surface heights and
+left the wraps 5.4 mm out of step, which no budget could see.
 
 ## Budgets
 
 Declared as named constants; every gate **recomputes** from the mesh,
-materials, UVs, evaluated LOD, collider, or export file.
+materials, UVs, evaluated LOD, collider, or export file. Measurements
+below are identical on 4.5.11, 5.1.2 and 5.2.1 — construction uses no
+RNG and no version-dependent operator.
 
 | Axis | Declared | Measured (4.5.11 / 5.1.2 / 5.2.1) |
 | --- | --- | --- |
-| Base triangles | 750–1100 | 852 / 852 / 852 |
-| LOD1 ratio | 0.32–0.62 of base | 0.5000 / 0.5000 / 0.5000 |
-| LOD2 ratio | 0.10–0.35 of base | 0.2183 / 0.2183 / 0.2183 |
-| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 294 hay, 132 twine |
+| Base triangles | 1700–2400 | 2012 on all three |
+| LOD1 ratio | 0.32–0.62 of base | 0.5000 |
+| LOD2 ratio | 0.10–0.35 of base | 0.2197 |
+| Materials | exactly 2 distinct, ≥24 hay, ≥24 twine | 2 slots, 712 hay, 304 twine |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (0.920, 0.517, 0.426) m ± 0.01 | (0.9199, 0.5170, 0.4257) |
-| Grounded zmin | within 1e-4 of 0 | 0 / 0 / 0 |
-| Hygiene | loose/nonman/zero-area/doubles/ngons = 0 | 0 / 0 / 0 |
-| Hay–twine gap | BVH surface < 0.008 m | 0.00007 / 0.00007 / 0.00007 |
-| Collider tris | ≤ 400 | 78 |
-| Export | written, size > 0 | 70720 / 70720 / 70712 bytes |
-
-DECIMATE COLLAPSE triangle counts are **not** identical across series —
-the gate is a ratio band, not an exact count. Bake pixels are
-stochastic; the gate is `has_data` plus operator `FINISHED`, not
-byte-identity. Construction uses no RNG. Export byte counts differ by
-8 B on 5.2.1 (glTF serializer), not a gated axis.
-
-`--skip-decimate` skips the LOD DECIMATE stage so LOD1 ratio is 1.0 and
-exit 9 fires. `--lift-z` raises the mesh 5 cm so the grounded-zmin
-hygiene budget fails and exit 16 fires.
+| Outer AABB | (0.922, 0.530, 0.409) m ± 0.01 | (0.9208, 0.5295, 0.4087) |
+| Grounded zmin | within 1e-4 of 0 | 0.000000 |
+| Hygiene | loose/nonman/zero-area/doubles/n-gons/**z-fight** = 0 | all 0 |
+| Shell count | exactly 5 (loaf, 2 belts, 2 loops) | 5 |
+| **Belt wrap zmin** | each belt shell ≤ 0.006 m | 0.002628 both |
+| **Belt seat depth** | every station in [0.002, 0.020] m | 0.00400..0.01676 over 20/20 stations, both belts |
+| **Mirror symmetry** | belts and loops matched within 5e-4 m | 0.000000 |
+| **Cinch depth** | mid-span minus waist in [0.006, 0.020] m | 0.01420 |
+| Loaf X × Z | (0.922, 0.409) m ± 0.02 | (0.9208, 0.4087) |
+| Hay–twine gap | BVH surface < 0.008 m | 0.00002 |
+| Collider tris | ≤ 400 | 156 |
+| Export | written, size > 0 | 156664 / 156664 / 156656 bytes |
+
+DECIMATE COLLAPSE triangle counts are **not** guaranteed identical
+across series — the gate is a ratio band, not an exact count. Bake
+pixels are stochastic; the gate is `has_data` plus operator `FINISHED`,
+not byte-identity. Export byte counts differ by 8 B on 5.2.1 (glTF
+serializer), which is not a gated axis; every geometric figure above is
+identical on all three binaries.
+
+The export is deleted once its size is measured. Blender sets `TMPDIR`
+from its own preference, which resolves to the working directory on a
+stock portable build, so `tempfile.gettempdir()` is the repo root under
+CI and every run used to leave a `.glb` behind.
+
+### Why these budgets and not an AABB
+
+`zmin` alone cannot see a belt that stops at the bottom edge: the loaf
+still grounds the box. A single global hay-twine gap cannot see a wrap
+that hugs one side and gaps the other. A bounding box cannot see two
+belts 5.4 mm out of step, or a flank with no waist in it. Each of the
+five budgets in bold above exists because a defect got past everything
+else and had to be found by looking at a render.
+
+The z-fight count is taken over **cross-shell** face pairs, not merely
+over faces that share no vertex: two quads two steps apart on one flat
+cap share no vertex and are coplanar by construction, and counting those
+reported 96 pairs, none of them a hazard.
+
+## Falsifiers
+
+Each breaks one stage so a **named** budget fails and the piece exits
+that code. All six proven on 4.5.11, 5.1.2 and 5.2.1.
+
+| Flag | Target budget | Exit |
+| --- | --- | --- |
+| `--skip-decimate` | LOD1 ratio band | 9 |
+| `--stray-vert` | hygiene: loose vertices | 15 |
+| `--lift-z` | grounded AABB zmin | 16 |
+| `--float-belts` | per-belt wrap zmin | 16 |
+| `--slack-belt` | banded belt seat depth | 18 |
+| `--skew-belt` | belt mirror symmetry | 19 |
+
+`--stray-vert` parks its loose vertex **inside** the bale: above it, the
+bounding-box budget (exit 8) fired first and the run proved nothing
+about hygiene. `--skew-belt` shifts one belt along **X** rather than Z
+for the same reason — a Z skew landed a belt face coplanar with a loaf
+face and tripped the z-fight budget (exit 15) instead of its target.
+`--float-belts` moves twine only, so the loaf still grounds the AABB and
+the per-belt gate has to be the thing that fires.
 
 ## Run
 
 ```bash
 blender --background --python hay_bale.py --
 blender --background --python hay_bale.py -- --skip-decimate
+blender --background --python hay_bale.py -- --stray-vert
 blender --background --python hay_bale.py -- --lift-z
+blender --background --python hay_bale.py -- --float-belts
+blender --background --python hay_bale.py -- --slack-belt
+blender --background --python hay_bale.py -- --skew-belt
 blender --background --python hay_bale.py -- --output bale.png
 ```
 
-Smoke does not pass `--output`, `--skip-decimate`, or `--lift-z`.
+Smoke does not pass `--output` or any falsifier flag.
+
+## Shading
+
+Decided per part, not globally. The loaf is **flat**-shaded: straw is a
+chunky matte mass and the facets read as compressed flakes. Smoothing
+the whole bale erased every ridge and nap in it and left a featureless
+pillow that read as a bar of soap. Twine is cord, so the belts and
+hitch loops stay smooth.
+
+The low mesh carries the form — bulge, waist, ridges, end strata — and
+the **high mesh carries the straw**: `LOAF_CUTS_HIGH` subdivision plus
+per-band flake offsets, moved onto the low mesh by the bake stage. A low
+mesh dense enough to model flakes directly would cost thousands of
+triangles for detail this piece already has a bake for.
+
+## Known gap
+
+At hero scale the piece still reads as a wrapped parcel rather than as
+straw. The form, the binding and the hygiene are right; the surface is
+not. The next pass on this piece belongs in the **material and bake**
+— straw needs directional fibre and colour break-up that a 256 px
+tangent-space normal off a smooth high mesh cannot deliver — not in more
+geometry. Recorded here so the next run does not re-litigate the
+silhouette.
 
 ## Exit codes
 
@@ -81,6 +176,8 @@ File-local. `9` is a valid check code. `10` is reserved for
 | 12 | Bake did not finish or image has no data |
 | 13 | Export file missing or empty |
 | 14 | `--output` produced no file |
-| 15 | Hygiene: loose verts/edges, non-manifold, zero-area, doubles, or n-gons |
-| 16 | Grounded zmin (`--lift-z` lands here) |
-| 17 | Hay–twine BVH gap above 8 mm |
+| 15 | Hygiene: loose, non-manifold, zero-area, doubles, n-gons, or cross-shell z-fight (`--stray-vert`) |
+| 16 | Grounded: AABB zmin (`--lift-z`), or a belt that does not wrap under (`--float-belts`) |
+| 17 | Shell count, or hay–twine BVH gap above 8 mm |
+| 18 | Banded belt seat depth (`--slack-belt`) |
+| 19 | Belt mirror symmetry (`--skew-belt`), cinch depth, or loaf real-world size |
diff --git a/showcase/hay-bale/hay_bale.py b/showcase/hay-bale/hay_bale.py
index 04fec2b2..1ede9837 100644
--- a/showcase/hay-bale/hay_bale.py
+++ b/showcase/hay-bale/hay_bale.py
@@ -43,19 +43,34 @@
 BALE_X = 0.90
 BALE_Y = 0.48
 BALE_Z = 0.38
-TWINE_T = 0.012
-TWINE_W = 0.028
-TWINE_EMBED = 0.003
+TWINE_T = 0.016
+TWINE_W = 0.024
+TWINE_EMBED = 0.004
 BELT_XS = (-0.225, 0.225)
-LOAF_CUTS = 4
+LOAF_CUTS = 8
+# The high mesh carries the straw; the bake moves it onto the low mesh. A
+# low mesh dense enough to model flakes directly would cost thousands of
+# triangles for detail this piece already has a bake stage to deliver.
+LOAF_CUTS_HIGH = 20
+FLAKE_W = 0.075
+FLAKE_AMP = 0.011
 BULGE = 0.055
-RIDGE_AMP = 0.007
+RIDGE_AMP = 0.014
 BBOX_TOL = 0.01
 # Fitted after locking geometry. Recomputed from bound_box.
-OUTER_SIZE = (0.920, 0.517, 0.426)
-
-BASE_TRIS_MIN = 750
-BASE_TRIS_MAX = 1100
+OUTER_SIZE = (0.922, 0.530, 0.409)
+
+# The belt follows the loaf's own cross-section, sampled by raycast, instead
+# of being a constant rectangle: a rectangle stands proud at the middle of
+# each face and is swallowed at the corners of a bulged loaf.
+BELT_SEGS = 20
+CINCH = 0.030          # fraction the loaf narrows under each belt
+CINCH_SIGMA = 0.075    # metres; how far the waist spreads either side
+NAP_AMP = 0.012        # end-grain bite, up from 0.010
+BASE_FLATTEN = 0.90    # how much of the pillow bulge gravity removes at z=0
+
+BASE_TRIS_MIN = 1700
+BASE_TRIS_MAX = 2400
 ZMIN_EPS = 1e-4
 DOUBLES_EPS = 1e-5
 AREA_EPS = 1e-10
@@ -76,6 +91,49 @@
 HAY_FACES_MIN = 24
 TWINE_FACES_MIN = 24
 
+# --- hygiene family, 15..19 -------------------------------------------------
+# Coplanar disjoint face pairs: count only faces that share NO vertex. The
+# triangles of one flat cap are coplanar and close-centred by construction.
+COPLANAR_NORMAL_EPS = 1e-4
+COPLANAR_PLANE_EPS = 1e-4
+COPLANAR_CENTRE_MAX = 0.05
+
+# loaf + 2 belts + 2 hitch loops
+SHELL_COUNT = 5
+
+# Each belt is a closed loop that passes *under* the loaf. A belt that stops
+# at the bottom edge leaves a visible notch while the loaf still grounds the
+# AABB, so the AABB zmin gate cannot see it: assert per belt shell.
+BELT_WRAP_ZMAX = 0.006
+
+# Banded seat depth, sampled per angular station around the belt rather than
+# as one global figure. A single figure passes while one side visibly gaps.
+SEAT_MIN = 0.002
+SEAT_MAX = 0.020
+# How far past flush the bottom run is pressed, so the belt stays inside the
+# Z=0 plane the bale is grounded on instead of poking through it.
+BELT_UNDER_SINK = 0.0012
+BELT_PRESS_H = 0.06
+
+# The two belts are mirror images. The odd ridge term used to put them
+# 5.4 mm out of step, which no budget could see.
+MIRROR_EPS = 5e-4
+
+# The cinch is what makes this a *bound* bale rather than a pillow, and it
+# is the one feature no other budget here touches: measured as the loaf's
+# half-width at a belt station against its half-width mid-span. Banded, so
+# neither a straight flank nor a strangled one passes.
+CINCH_MIN = 0.006
+CINCH_MAX = 0.020
+# Loaf length and height against the stated real-world bale. Y is left to
+# the cinch budget above, since the pillow bulge dominates it.
+LOAF_XZ = (0.922, 0.409)
+LOAF_XZ_TOL = 0.02
+
+FLOAT_BELT_Z = 0.02
+SLACK_BELT = 0.010
+SKEW_BELT_X = 0.004
+
 HAY_IDX = 0
 TWINE_IDX = 1
 
@@ -148,42 +206,84 @@ def add_rim(bm, loc, major, minor, mat_idx, euler=(0.0, 0.0, 0.0), n_major=12, n
     return verts
 
 
-def add_square_wrap(bm, x, y_half, z_lo, z_hi, t, w, mat_idx):
-    """Closed rectangular belt in YZ, extruded along X. One manifold torus."""
-    x0 = x - w * 0.5
-    x1 = x + w * 0.5
-    inner = (
-        (y_half, z_lo),
-        (y_half, z_hi),
-        (-y_half, z_hi),
-        (-y_half, z_lo),
-    )
-    outer = (
-        (y_half + t, z_lo - t),
-        (y_half + t, z_hi + t),
-        (-y_half - t, z_hi + t),
-        (-y_half - t, z_lo - t),
-    )
+def loaf_profile(bvh, x, centre, segs):
+    """Sample the loaf surface at station x, once per angular segment.
+
+    Returns [(y, z)] in the YZ plane. Raycasting the built loaf — rather
+    than evaluating the closed form — means the profile follows the bevel
+    and any later change to the shaping function for free.
+    """
+    cy, cz = centre
+    reach = max(BALE_X, BALE_Y, BALE_Z)
+    pts = []
+    for i in range(segs):
+        a = i * (2.0 * math.pi / segs)
+        d = Vector((0.0, math.cos(a), math.sin(a)))
+        origin = Vector((x, cy, cz))
+        # Cast inward from well outside: the outermost hit is the surface,
+        # so a concave waist cannot return an interior face.
+        far = origin + d * reach
+        hit, _nrm, _idx, dist = bvh.ray_cast(far, -d, reach * 2.0)
+        if hit is None:
+            hit, _nrm, _idx, dist = bvh.ray_cast(origin, d, reach)
+            if hit is None:
+                raise RuntimeError(f"loaf profile miss at x={x} a={a}")
+        pts.append((hit.y, hit.z))
+    return pts
+
+
+def add_belt_wrap(bm, x, profile, centre, t, w, embed, mat_idx):
+    """Closed belt following `profile`, extruded along X. One manifold loop.
+
+    The section is chamfered: a hard rectangle reads as masking tape at
+    this scale, and every real edge catches a little light.
+    """
+    cy, cz = centre
+    x0, x1 = x - w * 0.5, x + w * 0.5
+    xm0, xm1 = x - w * 0.5 + t * 0.5, x + w * 0.5 - t * 0.5
+
+    def offset(py, pz, d):
+        vy, vz = py - cy, pz - cz
+        n = math.hypot(vy, vz) or 1.0
+        return (py + vy / n * d, pz + vz / n * d)
+
+    def embed_at(_py, pz):
+        """Deeper where the run passes near the ground.
+
+        Keyed to the sampled point's own height, not to the ray angle: the
+        loaf's whole bottom face sits at Z=0, so several stations either
+        side of straight-down land on it, and an angle-keyed press leaves
+        those poking a fraction of a millimetre through the floor.
+
+        The load presses those runs flush and a little past flush, so the
+        belt never breaks the Z=0 plane the bale is grounded on, while the
+        top and side runs still stand proud enough to read.
+        """
+        press = max(0.0, 1.0 - pz / BELT_PRESS_H)
+        return embed + (t + BELT_UNDER_SINK - embed) * press
+
+    # inner surface sits `embed` inside the loaf; outer is `t` further out
+    inner = [offset(py, pz, -embed_at(py, pz)) for py, pz in profile]
+    outer = [offset(py, pz, -embed_at(py, pz) + t) for py, pz in profile]
 
     def ring(xc, pts):
         return [bm.verts.new((xc, p[0], p[1])) for p in pts]
 
-    i0 = ring(x0, inner)
-    o0 = ring(x0, outer)
-    i1 = ring(x1, inner)
-    o1 = ring(x1, outer)
+    i0, i1 = ring(x0, inner), ring(x1, inner)
+    o0, o1 = ring(xm0, outer), ring(xm1, outer)
 
     def quad(a, b, c, d):
-        face = bm.faces.new((a, b, c, d))
-        face.material_index = mat_idx
-        return face
+        f = bm.faces.new((a, b, c, d))
+        f.material_index = mat_idx
+        return f
 
-    for k in range(4):
-        n = (k + 1) % 4
-        quad(i0[k], i1[k], i1[n], i0[n])
-        quad(o0[k], o0[n], o1[n], o1[k])
-        quad(i0[k], i0[n], o0[n], o0[k])
-        quad(i1[k], o1[k], o1[n], i1[n])
+    n = len(profile)
+    for k in range(n):
+        m = (k + 1) % n
+        quad(i0[k], i1[k], i1[m], i0[m])   # inner face, against the loaf
+        quad(o0[k], o0[m], o1[m], o1[k])   # outer face
+        quad(i0[k], i0[m], o0[m], o0[k])   # -X chamfer
+        quad(i1[k], o1[k], o1[m], i1[m])   # +X chamfer
 
 
 def face_area(me, poly):
@@ -229,6 +329,150 @@ def hygiene_audit(me):
     }
 
 
+def mesh_shells(me):
+    """Vertex-index sets, one per edge-connected component.
+
+    A multi-body prop is not one shell, so Euler characteristic 2 is the
+    wrong contract for it; the shells are what the grounding, mirror and
+    seat budgets below are each measured over.
+    """
+    adj = [[] for _ in range(len(me.vertices))]
+    for e in me.edges:
+        a, b = e.vertices
+        adj[a].append(b)
+        adj[b].append(a)
+    seen, shells = set(), []
+    for start in range(len(me.vertices)):
+        if start in seen:
+            continue
+        stack, comp = [start], set()
+        while stack:
+            cur = stack.pop()
+            if cur in comp:
+                continue
+            comp.add(cur)
+            stack.extend(n for n in adj[cur] if n not in comp)
+        seen |= comp
+        shells.append(comp)
+    return shells
+
+
+def shell_stats(me, comp):
+    co = [me.vertices[i].co for i in comp]
+    return {
+        "n": len(comp),
+        "xmin": min(c.x for c in co), "xmax": max(c.x for c in co),
+        "ymin": min(c.y for c in co), "ymax": max(c.y for c in co),
+        "zmin": min(c.z for c in co), "zmax": max(c.z for c in co),
+    }
+
+
+def coplanar_zfight_pairs(me, shells):
+    """Coplanar face pairs from *different shells* — the z-fighting budget.
+
+    Cross-shell, not merely share-no-vertex. Two quads two steps apart on
+    one flat cap share no vertex and are coplanar and close-centred by
+    construction; counting those makes the budget unsatisfiable rather
+    than meaningful (96 pairs on this mesh, none of them a hazard).
+    Z-fighting is two separate bodies landing on one plane, which is
+    exactly a cross-shell pair.
+    """
+    owner = {}
+    for si, comp in enumerate(shells):
+        for vi in comp:
+            owner[vi] = si
+    faces = []
+    for p in me.polygons:
+        faces.append((p.normal.copy(), p.center.copy(),
+                      owner.get(p.vertices[0], -1)))
+    hits = 0
+    for i in range(len(faces)):
+        ni, ci, si = faces[i]
+        for j in range(i + 1, len(faces)):
+            nj, cj, sj = faces[j]
+            if si == sj:
+                continue
+            if (ci - cj).length > COPLANAR_CENTRE_MAX:
+                continue
+            if abs(abs(ni.dot(nj)) - 1.0) > COPLANAR_NORMAL_EPS:
+                continue
+            if abs(ni.dot(cj - ci)) > COPLANAR_PLANE_EPS:
+                continue
+            hits += 1
+    return hits
+
+
+def belt_seat_depths(me, loaf_comp, belt_comp, station_x, segs):
+    """Seat depth per angular station around one belt.
+
+    Banded and per-station, not one global figure: a single number passes
+    while one side of the wrap visibly gaps. The loaf surface is rebuilt
+    from the loaf shell of the *generated* mesh, so nothing here restates
+    a constant the builder set.
+    """
+    bm = bmesh.new()
+    try:
+        vmap = {}
+        for i in loaf_comp:
+            vmap[i] = bm.verts.new(me.vertices[i].co)
+        bm.verts.ensure_lookup_table()
+        for p in me.polygons:
+            if all(vi in vmap for vi in p.vertices):
+                try:
+                    bm.faces.new([vmap[vi] for vi in p.vertices])
+                except ValueError:
+                    pass
+        if not bm.faces:
+            return []
+        bvh = BVHTree.FromBMesh(bm)
+    finally:
+        pass
+    zs = [me.vertices[i].co.z for i in loaf_comp]
+    cz = 0.5 * (min(zs) + max(zs))
+    buckets = {}
+    for i in belt_comp:
+        co = me.vertices[i].co
+        a = math.atan2(co.z - cz, co.y)
+        # Round to the NEAREST station, do not floor into a bin. A station
+        # sitting on a bin boundary put its inner and outer rings in
+        # different bins, and the inner-only bin then reported the wrap as
+        # 12 mm outside the loaf — the outer ring's offset, exactly.
+        k = int(round((a + math.pi) / (2.0 * math.pi) * segs)) % segs
+        buckets.setdefault(k, []).append(co.copy())
+    reach = max(BALE_X, BALE_Y, BALE_Z) * 2.0
+
+    origin = Vector((station_x, 0.0, cz))
+
+    def depth(co):
+        """How far inside the station's own cross-section this point sits.
+
+        Measured along the point's own direction from the station axis,
+        NOT by nearest-surface distance. The belt lies in a concave waist,
+        so the nearest loaf face to a belt vertex is often on the bulge
+        shoulder 10 mm away at a neighbouring station, and the wrap then
+        reads as sitting outside a loaf it is in fact hugging.
+        """
+        a = math.atan2(co.z - cz, co.y)
+        d = Vector((0.0, math.cos(a), math.sin(a)))
+        hit, _nrm, _idx, _dd = bvh.ray_cast(origin + d * reach, -d, reach * 2.0)
+        if hit is None:
+            return None
+        return math.hypot(hit.y, hit.z - cz) - math.hypot(co.y, co.z - cz)
+
+    depths = []
+    for k in sorted(buckets):
+        # Per station, the deepest-seated point of the wrap: the inner
+        # ring. Picking the vertex nearest the belt axis instead looked
+        # equivalent but is not — the rings are unevenly spaced in angle
+        # once the bottom run is pressed in, so some buckets held only
+        # outer-ring vertices and reported the belt 10 mm outside.
+        vals = [d for d in (depth(co) for co in buckets[k]) if d is not None]
+        if vals:
+            depths.append(max(vals))
+    bm.free()
+    return depths
+
+
 def min_mat_distance(me, ia, ib):
     """Closest surface distance between two material islands via BVH.
 
@@ -307,7 +551,32 @@ def pack_uvs(bm, margin=0.08):
             )
 
 
-def _shape_loaf(verts):
+def _cinch(x):
+    """How much the loaf narrows at station x, from BELT_XS alone.
+
+    Derived from the belt positions rather than hand-placed, so moving a
+    belt moves its waist with it. A bound bale is defined by this waist;
+    without it the belts lie on a straight flank and nothing reads as tied.
+    """
+    return CINCH * sum(
+        math.exp(-((x - bx) / CINCH_SIGMA) ** 2) for bx in BELT_XS
+    )
+
+
+def _flake(x):
+    """Deterministic per-band offset. A bale is stacked flakes, and the
+    strata are what make it read as straw rather than as a carton.
+
+    Keyed to abs(x) so the pattern is EVEN, like every other term here:
+    an odd term puts the two belt stations on different surface heights.
+    Closed-form hash, no RNG, identical on every binary.
+    """
+    band = math.floor(abs(x) / FLAKE_W)
+    h = math.sin(band * 12.9898) * 43758.5453
+    return (h - math.floor(h)) - 0.5
+
+
+def _shape_loaf(verts, flake=False):
     hx = BALE_X * 0.5
     hy = BALE_Y * 0.5
     hz = BALE_Z * 0.5
@@ -317,20 +586,50 @@ def _shape_loaf(verts):
         nx = max(-1.0, min(1.0, x / hx))
         ny = max(-1.0, min(1.0, y / hy))
         nz = max(-1.0, min(1.0, (z - zc) / hz))
-        pillow = 1.0 + BULGE * (1.0 - nx * nx)
+        # Pillow bulge, waisted under every belt station.
+        pillow = (1.0 + BULGE * (1.0 - nx * nx)) * (1.0 - _cinch(x))
+        # Gravity flattens the face the bale rests on: take the bulge out as
+        # z falls to the base, so the bottom stays planar instead of doming
+        # down and being clamped flat afterwards.
+        grounded = 1.0 - BASE_FLATTEN * max(0.0, -nz) ** 2
         v.co.y = y * pillow
-        v.co.z = zc + (z - zc) * pillow
-        # Longitudinal straw ridges on the long faces; closed-form, no RNG.
-        ridge = RIDGE_AMP * math.sin(x * 24.0) * (0.35 + 0.65 * abs(ny))
-        v.co.y += ridge
-        v.co.z += 0.55 * RIDGE_AMP * math.sin(x * 19.0 + 0.7) * (0.35 + 0.65 * abs(nz))
+        v.co.z = zc + (z - zc) * (1.0 + (pillow - 1.0) * grounded)
+        # Longitudinal straw ridges on the long faces. cos(), not sin(): the
+        # term has to be EVEN in x or the two belt stations sample different
+        # surface heights and the belts end up out of step.
+        #
+        # Faded out under each belt, because the twine compresses the straw
+        # flat where it bites. Without this the ±14 mm ridge swamps the
+        # waist: the cinch measured 2.2 mm and read as a crease rather than
+        # as binding.
+        press = 1.0 - _cinch(x) / CINCH
+        v.co.y += RIDGE_AMP * math.cos(x * 24.0) * (0.35 + 0.65 * abs(ny)) * press
+        v.co.z += (
+            0.55 * RIDGE_AMP * math.cos(x * 19.0) * (0.35 + 0.65 * abs(nz))
+            * grounded * press
+        )
+        if flake:
+            f = _flake(x) * (0.35 + 0.65 * abs(ny))
+            v.co.y += FLAKE_AMP * f
+            v.co.z += FLAKE_AMP * 0.6 * _flake(x) * grounded
         # End-grain nap: bite the ±X faces instead of gluing on extra slabs.
+        # Damped to nothing at the face border, because the bevel runs after
+        # this: displacing the border verts turned the four corners into
+        # flared spikes. The ripple is slow (7, not 14) — at 14 it aliased
+        # against the subdivision grid and read as a checkerboard quilt.
         if abs(nx) > 0.82:
-            rr = math.hypot(v.co.y / (hy * pillow), (v.co.z - zc) / (hz * pillow))
-            v.co.x += math.copysign(0.010 * math.sin(rr * 14.0), x)
-
-
-def build_bale_mesh(name, bevel_offset, bevel_segments):
+            # Strata in Z, not rings in r. A cut bale end shows the flake
+            # layers edge-on; a concentric ripple is not what that looks
+            # like, and at BAKE_RES it resolved into a pixelated bullseye
+            # on the hero that read as a printed target.
+            edge = 1.0 - min(1.0, max(abs(ny), abs(nz))) ** 3
+            strata = math.sin((z / BALE_Z) * math.pi * 6.0)
+            v.co.x += math.copysign(NAP_AMP * strata * edge, x)
+
+
+def build_bale_mesh(name, bevel_offset, bevel_segments, cuts=LOAF_CUTS,
+                    flake=False, slack_belt=False, float_belts=False,
+                    skew_belt=False):
     bm = bmesh.new()
     hay_verts = []
     twine_faces = set()
@@ -346,11 +645,11 @@ def build_bale_mesh(name, bevel_offset, bevel_segments):
         bmesh.ops.subdivide_edges(
             bm,
             edges=list({e for v in hay_verts for e in v.link_edges}),
-            cuts=LOAF_CUTS,
+            cuts=cuts,
             use_grid_fill=True,
         )
         hay_verts = [v for v in bm.verts]
-        _shape_loaf(hay_verts)
+        _shape_loaf(hay_verts, flake=flake)
         if bevel_offset > 0.0:
             bm.edges.ensure_lookup_table()
             edges = []
@@ -371,59 +670,86 @@ def build_bale_mesh(name, bevel_offset, bevel_segments):
                 clamp_overlap=True,
             )
 
-        hay_now = [v for v in bm.verts]
+        # Ground and centre the LOAF first, then hang the belts on the
+        # finished surface. Placing them beforehand and shifting everything
+        # afterwards left each belt a few millimetres off the floor by a
+        # different amount, which is how they ended up out of step.
+        xs = [v.co.x for v in bm.verts]
+        ys = [v.co.y for v in bm.verts]
+        zmin = min(v.co.z for v in bm.verts)
+        cx = 0.5 * (min(xs) + max(xs))
+        cy = 0.5 * (min(ys) + max(ys))
+        for v in bm.verts:
+            v.co.x -= cx
+            v.co.y -= cy
+            v.co.z -= zmin
+
+        # Sample the loaf's own cross-section at each belt station.
+        loaf_bvh = BVHTree.FromBMesh(bm)
+        zs = [v.co.z for v in bm.verts]
+        centre = (0.0, 0.5 * (min(zs) + max(zs)))
+
         before = set(bm.faces)
         for x in BELT_XS:
-            near = [v for v in hay_now if abs(v.co.x - x) <= 0.08]
-            if len(near) < 8:
-                near = hay_now
-            y_max = max(abs(v.co.y) for v in near)
-            z_min = min(v.co.z for v in near)
-            z_max = max(v.co.z for v in near)
-            # Sit the belt in the ridge troughs so it cinches the peaks.
-            y_half = y_max - RIDGE_AMP - TWINE_EMBED
-            z_lo = z_min + RIDGE_AMP + TWINE_EMBED
-            z_hi = z_max - RIDGE_AMP - TWINE_EMBED
-            add_square_wrap(bm, x, y_half, z_lo, z_hi, TWINE_T, TWINE_W, TWINE_IDX)
+            profile = loaf_profile(loaf_bvh, x, centre, BELT_SEGS)
+            # --slack-belt backs one belt off the loaf so its seat depth
+            # drops below SEAT_MIN on every station of that belt.
+            embed = TWINE_EMBED - (SLACK_BELT if (slack_belt and x > 0) else 0.0)
+            add_belt_wrap(
+                bm, x, profile, centre, TWINE_T, TWINE_W, embed, TWINE_IDX,
+            )
+            # Hitch loop: the tail of the knot, lying flat on the bale top
+            # alongside its belt. Standing it upright made a wire hoop that
+            # broke the silhouette; laying it in XY reads as tied cord.
+            top_z = max(pz for _py, pz in profile)
             add_rim(
                 bm,
-                (x, 0.0, z_hi + TWINE_T),
-                0.014,
-                0.007,
+                # Offset outward from the centre, not along +X: a bare
+                # `x + TWINE_W` put the two loops at -0.201 and +0.249.
+                (x + math.copysign(TWINE_W, x), 0.052,
+                 top_z - TWINE_EMBED + TWINE_T * 0.45),
+                0.030,
+                0.0062,
                 TWINE_IDX,
-                euler=(math.pi / 2.0, 0.0, math.pi / 2.0),
-                n_major=10,
-                n_minor=5,
+                euler=(0.0, 0.0, 0.0),
+                n_major=12,
+                n_minor=6,
             )
         twine_faces.update(set(bm.faces) - before)
 
-        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
+        if float_belts or skew_belt:
+            # Move twine only. The loaf still grounds the AABB, so the
+            # outer-zmin gate stays green and the per-shell gate has to
+            # be the thing that fires.
+            moved = {v for f in twine_faces for v in f.verts}
+            for v in moved:
+                if float_belts:
+                    v.co.z += FLOAT_BELT_Z
+                elif v.co.x > 0.0:
+                    # Along X, not Z. A Z skew landed one belt face exactly
+                    # coplanar with a loaf face and tripped the z-fight
+                    # budget (exit 15) instead of the mirror budget it
+                    # targets. An X shift leaves every other budget alone:
+                    # the loaf profile barely changes over 4 mm, so the
+                    # seat band still passes and only the mirror fires.
+                    v.co.x += SKEW_BELT_X
 
-        zs = [v.co.z for v in bm.verts]
-        zmin = min(zs)
-        xs = [v.co.x for v in bm.verts]
-        ys = [v.co.y for v in bm.verts]
-        cx = 0.5 * (min(xs) + max(xs))
-        cy = 0.5 * (min(ys) + max(ys))
-        for v in bm.verts:
-            v.co.x -= cx
-            v.co.y -= cy
-            v.co.z -= zmin
-            if v.co.z < 0.0:
-                v.co.z = 0.0
+        bmesh.ops.remove_doubles(bm, verts=list(bm.verts), dist=DOUBLES_EPS)
 
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        # Shading is decided per part, not globally. Smooth-shading the
+        # whole bale erased every ridge and nap in it and left a featureless
+        # pillow that read as a bar of soap. Straw is a chunky matte mass:
+        # the loaf is flat-shaded so its facets read as compressed flakes.
+        # Twine is cord, so the belts and hitch loops stay smooth.
+        live_twine = {f for f in twine_faces if f.is_valid}
         for face in bm.faces:
-            face.smooth = True
+            face.smooth = face in live_twine
         for edge in bm.edges:
-            edge.smooth = True
-            if edge.is_manifold and len(edge.link_faces) == 2:
-                if edge.calc_face_angle() > math.radians(38.0):
-                    edge.smooth = False
-        for f in twine_faces:
-            if f.is_valid:
-                f.material_index = TWINE_IDX
+            edge.smooth = all(f in live_twine for f in edge.link_faces)
+        for f in live_twine:
+            f.material_index = TWINE_IDX
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
@@ -599,10 +925,19 @@ def export_unity(path, objects):
     )
 
 
-def check(skip_decimate, lift_z=False):
+def check(skip_decimate, lift_z=False, stray_vert=False, slack_belt=False,
+          float_belts=False, skew_belt=False):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    low = build_bale_mesh("BaleLow", bevel_offset=0.016, bevel_segments=2)
-    high = build_bale_mesh("BaleHigh", bevel_offset=0.016, bevel_segments=4)
+    low = build_bale_mesh(
+        "BaleLow", bevel_offset=0.016, bevel_segments=2,
+        slack_belt=slack_belt, float_belts=float_belts, skew_belt=skew_belt,
+    )
+    # The high mesh is where the straw lives: finer subdivision plus the
+    # flake strata. bake_normal moves that detail onto the low mesh.
+    high = build_bale_mesh(
+        "BaleHigh", bevel_offset=0.016, bevel_segments=4,
+        cuts=LOAF_CUTS_HIGH, flake=True,
+    )
     hay = principled(
         "BaleHay",
         (0.66, 0.52, 0.18, 1.0),
@@ -625,6 +960,16 @@ def check(skip_decimate, lift_z=False):
         for v in low.data.vertices:
             v.co.z += LIFT_Z
         low.data.update()
+    if stray_vert:
+        bm = bmesh.new()
+        bm.from_mesh(low.data)
+        # Inside the existing AABB: a stray vertex parked above the bale
+        # blew the bounding-box budget (exit 8) before the hygiene gate
+        # could see it, so it proved nothing about hygiene.
+        bm.verts.new((0.0, 0.0, BALE_Z * 0.5))
+        bm.to_mesh(low.data)
+        bm.free()
+        low.data.update()
 
     if low.data is None or len(low.data.polygons) < 6:
         return fail("hay bale mesh did not build", 3), None, None, None, None, None
@@ -669,6 +1014,15 @@ def check(skip_decimate, lift_z=False):
         os.remove(export_path)
     export_unity(export_path, [low, collider])
     export_size = os.path.getsize(export_path) if os.path.isfile(export_path) else 0
+    # Blender sets TMPDIR from its own preference, which resolves to the
+    # working directory on a stock portable build — so gettempdir() is the
+    # repo root under CI and every run left a .glb behind. The budget only
+    # needs the byte count, so drop the file once it is measured.
+    if os.path.isfile(export_path):
+        try:
+            os.remove(export_path)
+        except OSError:
+            pass
 
     print(
         f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}"
@@ -686,7 +1040,89 @@ def check(skip_decimate, lift_z=False):
         f"outer={OUTER_SIZE} zmin={bb[2]:.4f}"
     )
     hyg = hygiene_audit(low.data)
+    zfight = 0  # recomputed below, once the shells are known
     gap = min_mat_distance(low.data, TWINE_IDX, HAY_IDX)
+
+    # --- shells: loaf, two belts, two hitch loops ------------------------
+    shells = mesh_shells(low.data)
+    n_shells = len(shells)
+    zfight = coplanar_zfight_pairs(low.data, shells)
+    stats = [shell_stats(low.data, c) for c in shells]
+    order = sorted(range(len(shells)), key=lambda i: stats[i]["n"])
+    loaf_i = order[-1]
+    loaf_comp = shells[loaf_i]
+    core_x = stats[loaf_i]["xmax"] - stats[loaf_i]["xmin"]
+    core_y = stats[loaf_i]["ymax"] - stats[loaf_i]["ymin"]
+    core_z = stats[loaf_i]["zmax"] - stats[loaf_i]["zmin"]
+
+    # A belt is a non-loaf shell that spans most of the loaf's height; a
+    # hitch loop sits on the top run and spans almost none of it.
+    belt_shells, loop_shells = [], []
+    for i, st in enumerate(stats):
+        if i == loaf_i:
+            continue
+        bx = 0.5 * (st["xmin"] + st["xmax"])
+        span = st["zmax"] - st["zmin"]
+        (belt_shells if span > core_z * 0.5 else loop_shells).append((bx, st))
+    belt_shells.sort(key=lambda t: t[0])
+    loop_shells.sort(key=lambda t: t[0])
+
+    # --- mirror symmetry -------------------------------------------------
+    # The two wraps are mirror images. An odd term in the shaping function
+    # used to put them 5.4 mm out of step and no budget could see it.
+    def mirror_error(pairs):
+        if len(pairs) != 2:
+            return float("inf")
+        (xa, a), (xb, b) = pairs
+        return max(
+            abs(xa + xb),
+            abs(a["zmin"] - b["zmin"]),
+            abs(a["zmax"] - b["zmax"]),
+            abs((a["ymax"] - a["ymin"]) - (b["ymax"] - b["ymin"])),
+        )
+
+    mirror_err = max(mirror_error(belt_shells), mirror_error(loop_shells))
+
+    # --- banded seat depth, per angular station --------------------------
+    seat_depths = []
+    for bx, st in belt_shells:
+        comp = next(
+            c for i, c in enumerate(shells)
+            if i != loaf_i and abs(0.5 * (stats[i]["xmin"] + stats[i]["xmax"]) - bx) < 1e-9
+            and (stats[i]["zmax"] - stats[i]["zmin"]) > core_z * 0.5
+        )
+        seat_depths.append((bx, belt_seat_depths(
+            low.data, loaf_comp, comp, bx, BELT_SEGS)))
+
+    # --- cinch depth: the waist the belts pull into the loaf -------------
+    def half_y_at(x0, half_window):
+        ys = [
+            abs(low.data.vertices[i].co.y)
+            for i in loaf_comp
+            if abs(low.data.vertices[i].co.x - x0) <= half_window
+            and 0.30 * core_z <= low.data.vertices[i].co.z <= 0.70 * core_z
+        ]
+        return max(ys) if ys else 0.0
+
+    win = 0.5 * (BALE_X / (LOAF_CUTS + 1))
+    waist = min(half_y_at(bx, win) for bx in BELT_XS)
+    midspan = half_y_at(0.0, win)
+    cinch_depth = midspan - waist
+
+    print(
+        f"measured shells={n_shells} loaf=({core_x:.4f},{core_y:.4f},{core_z:.4f}) "
+        f"mirror_err={mirror_err:.6f} zfight={zfight}"
+    )
+    print(
+        f"measured cinch waist={waist:.5f} midspan={midspan:.5f} "
+        f"depth={cinch_depth:.5f}"
+    )
+    for bx, st in belt_shells:
+        print(f"measured belt x={bx:+.4f} zmin={st['zmin']:.6f}")
+    for bx, d in seat_depths:
+        if d:
+            print(f"measured seat x={bx:+.4f} n={len(d)} "
+                  f"min={min(d):.5f} max={max(d):.5f}")
     print(
         f"measured collider_tris={col_tris} bake={bake_result} "
         f"bake_has_data={img.has_data} export_bytes={export_size}"
@@ -768,11 +1204,13 @@ def check(skip_decimate, lift_z=False):
         or hyg["zero_area"]
         or hyg["doubles"]
         or hyg["ngons"]
+        or zfight
     ):
         return fail(
             f"hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
             f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
-            f"doubles={hyg['doubles']} ngons={hyg['ngons']}",
+            f"doubles={hyg['doubles']} ngons={hyg['ngons']} zfight={zfight} "
+            "(--stray-vert is the designed fail)",
             15,
         ), None, None, None, None, None
     if abs(bb[2]) > ZMIN_EPS:
@@ -781,11 +1219,60 @@ def check(skip_decimate, lift_z=False):
             "(--lift-z is the designed fail)",
             16,
         ), None, None, None, None, None
+    # The AABB gate above cannot see a belt that stops at the bottom edge:
+    # the loaf still grounds the box. Assert each belt loop passes UNDER
+    # the loaf, which is what a bound bale's twine does.
+    for bx, st in belt_shells:
+        if st["zmin"] > BELT_WRAP_ZMAX:
+            return fail(
+                f"belt at x={bx:+.3f} zmin {st['zmin']:.6f} > {BELT_WRAP_ZMAX} "
+                "— the loop stops at the bottom edge instead of wrapping "
+                "under (--float-belts is the designed fail)",
+                16,
+            ), None, None, None, None, None
+    if n_shells != SHELL_COUNT:
+        return fail(
+            f"shell count {n_shells} != {SHELL_COUNT}",
+            17,
+        ), None, None, None, None, None
     if gap > GAP_MAX:
         return fail(
             f"hay-twine gap {gap:.5f} > {GAP_MAX} (twine must cinch the loaf)",
             17,
         ), None, None, None, None, None
+    for bx, depths in seat_depths:
+        if not depths:
+            return fail(f"belt at x={bx:+.3f} sampled no seat station", 18), \
+                None, None, None, None, None
+        lo, hi = min(depths), max(depths)
+        if lo < SEAT_MIN or hi > SEAT_MAX:
+            return fail(
+                f"belt at x={bx:+.3f} seat depth {lo:.5f}..{hi:.5f} outside "
+                f"[{SEAT_MIN}, {SEAT_MAX}] over {len(depths)} stations "
+                "(--slack-belt is the designed fail)",
+                18,
+            ), None, None, None, None, None
+    if mirror_err > MIRROR_EPS:
+        return fail(
+            f"belts out of step by {mirror_err:.6f} > {MIRROR_EPS} — the two "
+            "wraps are not mirror images (--skew-belt is the designed fail)",
+            19,
+        ), None, None, None, None, None
+    if not (CINCH_MIN <= cinch_depth <= CINCH_MAX):
+        return fail(
+            f"cinch depth {cinch_depth:.5f} outside [{CINCH_MIN}, {CINCH_MAX}] "
+            "— the belts lie on a straight flank, so nothing reads as bound",
+            19,
+        ), None, None, None, None, None
+    if (
+        abs(core_x - LOAF_XZ[0]) > LOAF_XZ_TOL
+        or abs(core_z - LOAF_XZ[1]) > LOAF_XZ_TOL
+    ):
+        return fail(
+            f"loaf ({core_x:.4f} x {core_z:.4f}) off the stated "
+            f"{LOAF_XZ} m bale",
+            19,
+        ), None, None, None, None, None
     return 0, low, high, hay, tex, collider
 
 
@@ -806,7 +1293,10 @@ def render_still(low, hay, tex, path, engine):
             ob.hide_render = True
             ob.hide_viewport = True
 
-    low.rotation_euler.z = math.radians(-32.0)
+    # A bale is identified by its long ribbed flank and the two belts
+    # crossing it, not by its end. -32 deg swung the end face at the lens
+    # and it dominated the frame.
+    low.rotation_euler.z = math.radians(-20.0)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -847,12 +1337,19 @@ def light(name, loc, energy, size, col, rot):
 
     light("Key", (-3.6, -5.0, 5.4), 660.0, 4.0, (1.0, 0.94, 0.86), (50, 0, -36))
     light("Fill", (5.0, -3.4, 2.4), 46.0, 8.0, (0.72, 0.82, 1.0), (62, 0, 50))
-    light("Wedge", (2.2, 4.0, 3.8), 600.0, 5.5, (1.0, 0.70, 0.40), (-70, 0, 198))
+    # Wedge brought in and down with the camera. Pulling the lens back to
+    # 70 mm left the warm pool falling outside the frame, and the first
+    # contact sheet showed a neutral grey stage against a calibration set
+    # that all carry one.
+    light("Wedge", (1.5, 2.6, 2.1), 900.0, 4.0, (1.0, 0.63, 0.32), (-62, 0, 205))
 
     cam_data = bpy.data.cameras.new("Cam")
-    cam_data.lens = 50.0
+    # 70 mm from further back rather than 50 mm up close: at 2.1 m a 50 mm
+    # lens put enough perspective on a 0.92 m subject that the near end
+    # read half again as large as the far one.
+    cam_data.lens = 70.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (1.26, -1.53, 0.88)
+    cam.location = (1.74, -2.28, 1.16)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
     aim.location = (0.0, 0.0, 0.15)
@@ -908,9 +1405,39 @@ def main():
         action="store_true",
         help="falsification: lift the mesh so zmin fails the grounded budget",
     )
+    p.add_argument(
+        "--stray-vert",
+        action="store_true",
+        help="falsification: add a loose vertex so the hygiene budget fails",
+    )
+    p.add_argument(
+        "--float-belts",
+        action="store_true",
+        help="falsification: lift the belts off the floor so the per-belt "
+             "wrap budget fails while the loaf still grounds the AABB",
+    )
+    p.add_argument(
+        "--slack-belt",
+        action="store_true",
+        help="falsification: back one belt off the loaf so its banded seat "
+             "depth falls below the minimum",
+    )
+    p.add_argument(
+        "--skew-belt",
+        action="store_true",
+        help="falsification: raise one belt so the two wraps stop being "
+             "mirror images",
+    )
     args = p.parse_args(argv)
 
-    code, low, _high, hay, tex, _col = check(args.skip_decimate, lift_z=args.lift_z)
+    code, low, _high, hay, tex, _col = check(
+        args.skip_decimate,
+        lift_z=args.lift_z,
+        stray_vert=args.stray_vert,
+        float_belts=args.float_belts,
+        slack_belt=args.slack_belt,
+        skew_belt=args.skew_belt,
+    )
     if code:
         return code
     if args.output:
diff --git a/showcase/hay-bale/preview.webp b/showcase/hay-bale/preview.webp
index 2092fb30..bedb19fb 100644
Binary files a/showcase/hay-bale/preview.webp and b/showcase/hay-bale/preview.webp differ