diff --git a/docs/gallery/assets/export-preset-axis-hero.webp b/docs/gallery/assets/export-preset-axis-hero.webp
index 842f6f55..8dfc7483 100644
Binary files a/docs/gallery/assets/export-preset-axis-hero.webp and b/docs/gallery/assets/export-preset-axis-hero.webp differ
diff --git a/docs/gallery/assets/terrain-scatter-hero.webp b/docs/gallery/assets/terrain-scatter-hero.webp
index 31dc7538..bc375bcd 100644
Binary files a/docs/gallery/assets/terrain-scatter-hero.webp and b/docs/gallery/assets/terrain-scatter-hero.webp differ
diff --git a/docs/gallery/contact-sheets/export-preset-axis-contact-sheet.webp b/docs/gallery/contact-sheets/export-preset-axis-contact-sheet.webp
index 2e10ee39..095161f4 100644
Binary files a/docs/gallery/contact-sheets/export-preset-axis-contact-sheet.webp and b/docs/gallery/contact-sheets/export-preset-axis-contact-sheet.webp differ
diff --git a/docs/gallery/contact-sheets/terrain-scatter-contact-sheet.webp b/docs/gallery/contact-sheets/terrain-scatter-contact-sheet.webp
index 099cdccf..f45055fb 100644
Binary files a/docs/gallery/contact-sheets/terrain-scatter-contact-sheet.webp and b/docs/gallery/contact-sheets/terrain-scatter-contact-sheet.webp differ
diff --git a/docs/gallery/export-preset-axis/index.html b/docs/gallery/export-preset-axis/index.html
index f9730023..91b05ca9 100644
--- a/docs/gallery/export-preset-axis/index.html
+++ b/docs/gallery/export-preset-axis/index.html
@@ -697,8 +697,10 @@ <h2>Source</h2>
     scene = bpy.context.scene
     source.hide_render = <span class="k">True</span>
     source.hide_viewport = <span class="k">True</span>
-    sit_on_floor(unity_objs, -<span class="n">2.15</span>, <span class="n">0.0</span>)
-    sit_on_floor(godot_objs, <span class="n">1.95</span>, <span class="n">0.0</span>)
+    <span class="c"># Closer together: at -2.15 / +1.95 the pair left an empty metre of floor</span>
+    <span class="c"># between them, and each prop was small in its half of the frame.</span>
+    sit_on_floor(unity_objs, -<span class="n">1.35</span>, <span class="n">0.0</span>)
+    sit_on_floor(godot_objs, <span class="n">1.35</span>, <span class="n">0.0</span>)
 
     floor_me = bpy.data.meshes.new(<span class="s">&quot;Floor&quot;</span>)
     bm = bmesh.new()
@@ -734,10 +736,14 @@ <h2>Source</h2>
     cam_data = bpy.data.cameras.new(<span class="s">&quot;Cam&quot;</span>)
     cam_data.lens = <span class="n">50.0</span>
     cam = bpy.data.objects.new(<span class="s">&quot;Cam&quot;</span>, cam_data)
-    cam.location = (<span class="n">3.12</span>, -<span class="n">8.15</span>, <span class="n">2.45</span>)
+    <span class="c"># Oblique rather than straight down +Y: the Godot reimport lies with its</span>
+    <span class="c"># mast along -Y, and a camera looking along Y foreshortened that mast to</span>
+    <span class="c"># a stub in front of the base plate, so the one thing the check proves</span>
+    <span class="c"># (it lies) barely read. From the side-front the mast shows its length.</span>
+    cam.location = (<span class="n">4.9</span>, -<span class="n">5.1</span>, <span class="n">2.2</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.85</span>)
+    aim.location = (<span class="n">0.40</span>, -<span class="n">0.30</span>, <span class="n">1.00</span>)
     scene.collection.objects.link(aim)
     con = cam.constraints.new(<span class="s">&quot;TRACK_TO&quot;</span>)
     con.target = aim
diff --git a/docs/gallery/index.html b/docs/gallery/index.html
index b63d0705..0d622708 100644
--- a/docs/gallery/index.html
+++ b/docs/gallery/index.html
@@ -981,7 +981,7 @@ <h2><a href="treasure-chest/">treasure-chest</a></h2>
       </article>
       <article class="card" data-tags="mesh export showcase">
         <a class="card-media" href="terrain-scatter/" tabindex="-1" aria-hidden="true">
-          <img src="assets/terrain-scatter-hero.webp" alt="A square tile of sandy rolling terrain with pale rocks scattered on the hill." loading="lazy" decoding="async" />
+          <img src="assets/terrain-scatter-hero.webp" alt="A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching." loading="lazy" decoding="async" />
         </a>
         <div class="card-body">
           <h2><a href="terrain-scatter/">terrain-scatter</a></h2>
diff --git a/docs/gallery/terrain-scatter/index.html b/docs/gallery/terrain-scatter/index.html
index 056d0277..ca989940 100644
--- a/docs/gallery/terrain-scatter/index.html
+++ b/docs/gallery/terrain-scatter/index.html
@@ -16,13 +16,13 @@
   <meta property="og:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/terrain-scatter-hero.webp" />
   <meta property="og:image:width" content="1280" />
   <meta property="og:image:height" content="720" />
-  <meta property="og:image:alt" content="A square tile of sandy rolling terrain with pale rocks scattered on the hill." />
+  <meta property="og:image:alt" content="A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching." />
   <meta property="og:site_name" content="Blender Developer Tools" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="terrain-scatter — Showcase — Blender Developer Tools" />
   <meta name="twitter:description" content="A Geometry Nodes hill tile with seated icosphere scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract." />
   <meta name="twitter:image" content="https://tmhsdigital.github.io/Blender-Developer-Tools/gallery/assets/terrain-scatter-hero.webp" />
-  <meta name="twitter:image:alt" content="A square tile of sandy rolling terrain with pale rocks scattered on the hill." />
+  <meta name="twitter:image:alt" content="A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching." />
   <style>
     /* fonts are deployed by the landing build (docs/fonts/) */
     @font-face { font-family: 'Barlow Condensed'; font-weight: 600; font-display: swap;
@@ -268,8 +268,8 @@ <h1>terrain-scatter</h1>
     <p>A Geometry Nodes hill tile with seated icosphere scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.</p>
   </header>
   <main id="main">
-    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A square tile of sandy rolling terrain with pale rocks scattered on the hill.">
-      <img src="../assets/terrain-scatter-hero.webp" alt="A square tile of sandy rolling terrain with pale rocks scattered on the hill." width="1280" height="720" />
+    <button class="detail-hero" id="heroZoom" type="button" aria-label="View full size: A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching.">
+      <img src="../assets/terrain-scatter-hero.webp" alt="A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching." 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: 1758 tris, two materials with 720 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.552 m, grounded zmin, 9 stones of ≥80 faces seated on sampled dirt Z (offset −35 mm, floor zmin 0.113 m), LOD ratios in band, convex collider 81 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --poke-rock 17; --float-rocks 18; --box-rocks 19.</div>
@@ -278,22 +278,26 @@ <h1>terrain-scatter</h1>
       <button class="copy-btn" id="copyRun" type="button">Copy</button>
     </div>
     <section class="detail-section md">
-<p>A showcase piece, not an example. Geometry Nodes sine-hill Mesh Grid with an Index-jittered Instance-on-Points scatter, realized cubes replaced by closed-form displaced icospheres seated on sampled dirt Z, 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. Geometry Nodes sine-hill Mesh Grid with an Index-jittered Instance-on-Points scatter, realized cubes replaced by closed-form cleaved, faceted stones seated on sampled dirt Z, then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal bake, LOD chain, convex collider, Unity glTF export.</p>
 <p>GN still builds the hill and the instance grid. After realize+slabify, cube islands are deleted and each centroid is reseated: stone <code>zmin</code> equals sampled dirt Z minus a named bite, then verts clamp above the slab floor. That is why rocks sit on the hill instead of punching through the slab as bevelled crates.</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>geometry-nodes-python</code>, <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: 1.80 m square hill tile, ~0.16 m sine amplitude, nine seated stones; outer AABB 1.800 × 1.800 × 0.552 m.</p>
+<p>Intended size: 1.80 m square hill tile, ~0.16 m sine amplitude, nine seated stones; outer AABB 1.800 × 1.800 × 0.584 m.</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>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1400–2800</td><td>1758 / 1758 / 1758</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.4994 / 0.4994 / 0.4994</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2196 / 0.2196 / 0.2196</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥24 stone faces</td><td>2 slots, 720 stone</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.800, 1.800, 0.552) m ± 0.015</td><td>(1.8000, 1.8000, 0.5523), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 120</td><td>81</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>158156 / 158156 / 158140 bytes</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (4.5.11 / 5.1.2 / 5.2.1)</th></tr></thead><tbody><tr><td>Base triangles</td><td>1400–2800</td><td>1758 / 1758 / 1758</td></tr><tr><td>LOD1 ratio</td><td>0.32–0.62 of base</td><td>0.4994 / 0.4994 / 0.4994</td></tr><tr><td>LOD2 ratio</td><td>0.10–0.35 of base</td><td>0.2196 / 0.2196 / 0.2196</td></tr><tr><td>Materials</td><td>exactly 2 distinct, ≥24 stone faces</td><td>2 slots, 720 stone</td></tr><tr><td>UVs</td><td>in <code>0..1</code>, AABB overlap ≤ 1e-5</td><td>in range, overlap 0</td></tr><tr><td>Outer AABB</td><td>(1.800, 1.800, 0.584) m ± 0.015</td><td>(1.8000, 1.8000, 0.5838), zmin 0</td></tr><tr><td>Collider tris</td><td>≤ 120</td><td>72</td></tr><tr><td>Export</td><td>written, size &gt; 0</td><td>157476 / 157476 / 157460 bytes</td></tr></tbody></table></div>
 <p>Base triangles rose from <strong>1194 to 1758</strong> in the quality pass: 9-vert hill became a 21-vert grid, and bevelled cubes became subdiv-2 icospheres. Outer Z dropped from 0.655 m (crate corners swinging through the slab) to 0.552 m of seated stone on the hill.</p>
-<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. This mesh matched on 4.5.11 / 5.1.2 / 5.2.1. 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 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
+<p>DECIMATE COLLAPSE triangle counts are <strong>not</strong> guaranteed identical across series — the gate is a ratio band, not an exact count. This mesh matched on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is <code>has_data</code> plus operator <code>FINISHED</code>, not byte-identity. Construction uses no RNG: jitter, cleave planes and relaxation are all closed form or fixed iteration. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not a gated axis.</p>
 <h3>Hygiene</h3>
 <p>Recomputed from the generated mesh, not asserted about the script.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Stone shells</td><td>9</td><td>9</td></tr><tr><td>Per-stone faces</td><td>≥ 40</td><td>80</td></tr><tr><td>Stone floor <code>zmin</code></td><td>≥ 0.012 m</td><td>0.11334</td></tr><tr><td>Seat offset (<code>zmin</code> − dirt Z)</td><td>≤ 0.02 m</td><td>−0.03500</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Axis</th><th scope="col">Declared</th><th scope="col">Measured (all three)</th></tr></thead><tbody><tr><td>Non-manifold edges</td><td>0</td><td>0</td></tr><tr><td>Loose verts / edges</td><td>0 / 0</td><td>0 / 0</td></tr><tr><td>Doubles merged at 1e-5</td><td>0</td><td>0</td></tr><tr><td>Zero-area faces</td><td>0</td><td>0</td></tr><tr><td>N-gons</td><td>0</td><td>0</td></tr><tr><td>Coplanar disjoint face pairs</td><td>0</td><td>0</td></tr><tr><td>Grounded: <code>zmin</code></td><td>within 1e-4 of 0</td><td>0.0000</td></tr><tr><td>Stone shells</td><td>9</td><td>9</td></tr><tr><td>Per-stone faces</td><td>≥ 40</td><td>80</td></tr><tr><td>Stone floor <code>zmin</code></td><td>≥ 0.012 m</td><td>0.11112</td></tr><tr><td>Seat offset (<code>zmin</code> − dirt Z)</td><td>≤ 0.02 m</td><td>−0.00745</td></tr><tr><td>Interpenetrating stone pairs (BVH overlap)</td><td>0</td><td>0</td></tr></tbody></table></div>
+<h3>Why the stones are cleaved, relaxed and faceted</h3>
+<p>The committed stones were smooth-shaded, near-white ellipsoids with a gentle sine bump: eggs or marshmallows on a pale clay slab. Two pairs also interpenetrated, because the GN scatter jitters by up to 0.22 m on a 0.575 m grid, and no budget compared stone to stone.</p>
+<ul><li><strong>Cleaved.</strong> Each ellipsoid is cut by <code>N_CLEAVES</code> planes whose normals and depths come from the stone&#x27;s own centre, closed form. Every vertex beyond a plane is projected onto it, which leaves flat broken faces. Stones are shaded flat, because broken rock is faceted; smooth shading turned the cleaved stones back into eggs.</li><li><strong>Scaled.</strong> Cleaving takes about a third off each stone, and at the old size they read as pebbles, so every semi-axis is <code>ROCK_SCALE</code> = 1.35×.</li><li><strong>Relaxed.</strong> Stone centres are pushed apart to <code>2 × STONE_R_BOUND + STONE_CLEAR</code> over a fixed number of symmetric passes, and clamped so each stone&#x27;s bound stays on the tile. <code>STONE_R_BOUND</code> is derived from <code>ROCK_SCALE</code> and the largest semi-axis, bump and tilt, so scaling the stones widens the spacing with them. With today&#x27;s numbers the unrelaxed scatter would also clear; the relaxation is what keeps that true when the scatter or the sizes change.</li><li><strong>Materials.</strong> Dark mottled soil and grey weathered stone, with roughness and a small bump from fine object-space noise.</li></ul>
+<p><code>stone_overlap_audit</code> BVH-tests every stone pair. <code>--pile-rocks</code> skips the relaxation and draws the scatter in to 40% so neighbours collide: 6 pairs interpenetrate on 5.2.1, and the piece exits 20. Skipping the relaxation alone would prove nothing, because the cleaved stones miss each other unrelaxed.</p>
 <h3>Falsifiers</h3>
 <p>Each violates one named budget. All were run on 4.5.11, 5.1.2 and 5.2.1 and returned the same code on each.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--poke-rock</code></td><td>stone floor <code>zmin</code></td><td>17</td></tr><tr><td><code>--float-rocks</code></td><td>seat offset vs sampled dirt Z</td><td>18</td></tr><tr><td><code>--box-rocks</code></td><td>per-stone face floor</td><td>19</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Flag</th><th scope="col">Budget violated</th><th scope="col">Exit</th></tr></thead><tbody><tr><td><code>--skip-decimate</code></td><td>LOD1 ratio band</td><td>9</td></tr><tr><td><code>--stray-vert</code></td><td>loose vertex count is 0</td><td>15</td></tr><tr><td><code>--lift-z</code></td><td>bounding box <code>zmin</code> is 0</td><td>16</td></tr><tr><td><code>--poke-rock</code></td><td>stone floor <code>zmin</code></td><td>17</td></tr><tr><td><code>--float-rocks</code></td><td>seat offset vs sampled dirt Z</td><td>18</td></tr><tr><td><code>--box-rocks</code></td><td>per-stone face floor</td><td>19</td></tr><tr><td><code>--pile-rocks</code></td><td>stone-to-stone interpenetration is 0</td><td>20</td></tr></tbody></table></div>
 <h2>Run</h2>
 <pre><code>blender --background --python terrain_scatter.py --
 blender --background --python terrain_scatter.py -- --skip-decimate
@@ -302,11 +306,12 @@ <h2>Run</h2>
 blender --background --python terrain_scatter.py -- --poke-rock
 blender --background --python terrain_scatter.py -- --float-rocks
 blender --background --python terrain_scatter.py -- --box-rocks
+blender --background --python terrain_scatter.py -- --pile-rocks
 blender --background --python terrain_scatter.py -- --output terrain.png</code></pre>
 <p>Smoke passes no flags.</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. <code>15</code>–<code>19</code> are the hygiene and joint-fit family.</p>
-<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or stone faces missing</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Hygiene (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin (<code>--lift-z</code>)</td></tr><tr><td>17</td><td>Stone floor poke (<code>--poke-rock</code>)</td></tr><tr><td>18</td><td>Float above host (<code>--float-rocks</code>)</td></tr><tr><td>19</td><td>Stone shell faces (<code>--box-rocks</code>)</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th scope="col">Code</th><th scope="col">Meaning</th></tr></thead><tbody><tr><td>0</td><td>Success</td></tr><tr><td>1</td><td>Uncaught exception (FATAL wrapper)</td></tr><tr><td>2</td><td>argparse / usage</td></tr><tr><td>3</td><td>Mesh did not build / no UV layer</td></tr><tr><td>4</td><td>Base triangle count outside range</td></tr><tr><td>5</td><td>Material count ≠ 2 distinct slots, or stone faces missing</td></tr><tr><td>6</td><td>UVs outside 0..1</td></tr><tr><td>7</td><td>UV AABB overlap above tolerance</td></tr><tr><td>8</td><td>World AABB off declared outer size</td></tr><tr><td>9</td><td>LOD ratio band (<code>--skip-decimate</code> lands here)</td></tr><tr><td>10</td><td>Framing gate (render path only)</td></tr><tr><td>11</td><td>Collider triangle count above ceiling</td></tr><tr><td>12</td><td>Bake did not finish or image has no data</td></tr><tr><td>13</td><td>Export file missing or empty</td></tr><tr><td>14</td><td><code>--output</code> produced no file</td></tr><tr><td>15</td><td>Hygiene (<code>--stray-vert</code> lands here)</td></tr><tr><td>16</td><td>Grounded zmin (<code>--lift-z</code>)</td></tr><tr><td>17</td><td>Stone floor poke (<code>--poke-rock</code>)</td></tr><tr><td>18</td><td>Float above host (<code>--float-rocks</code>)</td></tr><tr><td>19</td><td>Stone shell faces (<code>--box-rocks</code>)</td></tr><tr><td>20</td><td>Stone pairs interpenetrate (<code>--pile-rocks</code>)</td></tr></tbody></table></div>
     </section>
     <section class="detail-section src">
       <h2>Source</h2>
@@ -322,14 +327,15 @@ <h2>Source</h2>
 Unity glTF export.
 
 GN still builds the sine hill and the Index-jittered instance grid.
-Realized cubes are replaced with closed-form displaced icospheres seated
-on sampled dirt Z, then clamped above the slab floor.
+Realized cubes are replaced with closed-form cleaved, faceted stones,
+relaxed apart so no two interpenetrate, seated on sampled dirt Z, then
+clamped above the slab floor.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
 zmin, ``--poke-rock`` stone floor, ``--float-rocks`` seat, ``--box-rocks``
-stone shell faces.
+stone shell faces, ``--pile-rocks`` stone-to-stone interpenetration.
 
 No RNG. Hills are a closed-form sine product; scatter is an Index-jittered
 instance grid. DECIMATE COLLAPSE triangle counts are not byte-identical
@@ -349,6 +355,7 @@ <h2>Source</h2>
 <span class="k">import</span> bmesh
 <span class="k">import</span> bpy
 <span class="k">from</span> mathutils <span class="k">import</span> Euler, Vector
+<span class="k">from</span> mathutils.bvhtree <span class="k">import</span> BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -369,7 +376,7 @@ <h2>Source</h2>
 N_ROCKS = <span class="n">9</span>
 
 BBOX_TOL = <span class="n">0.015</span>
-OUTER_SIZE = (<span class="n">1.800</span>, <span class="n">1.800</span>, <span class="n">0.552</span>)
+OUTER_SIZE = (<span class="n">1.800</span>, <span class="n">1.800</span>, <span class="n">0.584</span>)
 BASE_TRIS_MIN = <span class="n">1400</span>
 BASE_TRIS_MAX = <span class="n">2800</span>
 LOD1_RATIO_MIN = <span class="n">0.32</span>
@@ -399,6 +406,24 @@ <h2>Source</h2>
 DIRT_IDX = <span class="n">0</span>
 STONE_IDX = <span class="n">1</span>
 
+<span class="c"># Stones are kept apart by relaxing their centres to at least twice a</span>
+<span class="c"># bound on any stone&#x27;s horizontal radius. The GN scatter jitters by up to</span>
+<span class="c"># 0.22 m on a 0.575 m grid, which pushed neighbours into each other: two</span>
+<span class="c"># pairs interpenetrated in the committed piece. The bound covers the</span>
+<span class="c"># largest ellipsoid semi-axis (0.135), the surface bump (0.016) and the</span>
+<span class="c"># lean tilt, so any two relaxed stones clear by construction.</span>
+<span class="c"># Stones are ROCK_SCALE times the base ellipsoid: cleaving takes a third of</span>
+<span class="c"># the volume off, and at 1.0 the cleaved stones read as pebbles on a slab.</span>
+ROCK_SCALE = <span class="n">1.35</span>
+STONE_R_BOUND = ROCK_SCALE * (<span class="n">0.135</span> + <span class="n">0.016</span> + <span class="n">0.22</span> * <span class="n">0.095</span>)
+STONE_CLEAR = <span class="n">0.02</span>
+RELAX_ITERS = <span class="n">40</span>
+PILE_PULL = <span class="n">0.40</span>
+<span class="c"># Each rock is cleaved by a few planes through its ellipsoid, so it reads</span>
+<span class="c"># as broken stone with flat faces rather than a smooth egg.</span>
+N_CLEAVES = <span class="n">5</span>
+CLEAVE_DEPTH = <span class="n">0.62</span>
+
 
 <span class="k">def</span> eevee_engine_id():
     <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>
@@ -707,9 +732,9 @@ <h2>Source</h2>
 
 
 <span class="k">def</span> add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
-    sx = <span class="n">0.11</span> + <span class="n">0.025</span> * math.sin(cx * <span class="n">8.1</span>)
-    sy = <span class="n">0.10</span> + <span class="n">0.022</span> * math.cos(cy * <span class="n">6.4</span>)
-    sz = <span class="n">0.075</span> + <span class="n">0.020</span> * math.sin(cx * <span class="n">4.2</span> + cy * <span class="n">3.1</span>)
+    sx = ROCK_SCALE * (<span class="n">0.11</span> + <span class="n">0.025</span> * math.sin(cx * <span class="n">8.1</span>))
+    sy = ROCK_SCALE * (<span class="n">0.10</span> + <span class="n">0.022</span> * math.cos(cy * <span class="n">6.4</span>))
+    sz = ROCK_SCALE * (<span class="n">0.075</span> + <span class="n">0.020</span> * math.sin(cx * <span class="n">4.2</span> + cy * <span class="n">3.1</span>))
     bite = POKE_BITE <span class="k">if</span> poke <span class="k">else</span> ROCK_BITE
     seat = dirt_z + FLOAT_LIFT <span class="k">if</span> float_up <span class="k">else</span> dirt_z - bite
     rot = Euler(
@@ -729,11 +754,24 @@ <h2>Source</h2>
         <span class="k">for</span> v <span class="k">in</span> verts:
             p = Vector((v.co.x * sx, v.co.y * sy, v.co.z * sz))
             <span class="k">if</span> p.length &gt; <span class="n">1e-8</span>:
-                bump = <span class="n">0.016</span> * math.sin(p.x * <span class="n">26.0</span> + cx * <span class="n">5.0</span>) * math.cos(
+                bump = ROCK_SCALE * <span class="n">0.016</span> * math.sin(p.x * <span class="n">26.0</span> + cx * <span class="n">5.0</span>) * math.cos(
                     p.y * <span class="n">21.0</span> + cy * <span class="n">4.0</span>
                 )
                 p += p.normalized() * bump
             v.co = rot @ p
+        <span class="c"># Cleave: project everything beyond each plane onto it. Plane</span>
+        <span class="c"># normals and depths come from the stone&#x27;s own centre, closed form,</span>
+        <span class="c"># so every stone breaks differently but reproducibly.</span>
+        <span class="k">for</span> k <span class="k">in</span> range(N_CLEAVES):
+            a = cx * (<span class="n">3.7</span> + k) + cy * (<span class="n">2.3</span> + <span class="n">1.7</span> * k) + <span class="n">0.9</span> * k
+            b = <span class="n">0.35</span> + <span class="n">0.9</span> * (<span class="n">0.5</span> + <span class="n">0.5</span> * math.sin(cx * <span class="n">5.3</span> + k * <span class="n">1.3</span> + cy))
+            n = Vector((math.cos(a) * math.sin(b), math.sin(a) * math.sin(b), math.cos(b)))
+            reach = max(abs(n.x) * sx, abs(n.y) * sy, abs(n.z) * sz)
+            d = CLEAVE_DEPTH * reach + <span class="n">0.15</span> * reach * math.sin(cy * <span class="n">7.1</span> + k)
+            <span class="k">for</span> v <span class="k">in</span> verts:
+                over = v.co.dot(n) - d
+                <span class="k">if</span> over &gt; <span class="n">0.0</span>:
+                    v.co -= n * over
         <span class="k">for</span> f <span class="k">in</span> {face <span class="k">for</span> v <span class="k">in</span> verts <span class="k">for</span> face <span class="k">in</span> v.link_faces}:
             f.material_index = STONE_IDX
     zmin = min(v.co.z <span class="k">for</span> v <span class="k">in</span> verts)
@@ -746,7 +784,39 @@ <h2>Source</h2>
             v.co.z = ROCK_ZMIN
 
 
-<span class="k">def</span> masonry_from_cubes(bm, box_rocks=<span class="k">False</span>, poke=<span class="k">False</span>, float_up=<span class="k">False</span>):
+<span class="k">def</span> relax_centres(specs, half_span):
+    <span class="s">&quot;&quot;&quot;Push stone centres apart to 2*STONE_R_BOUND + STONE_CLEAR, deterministically.
+
+    Pairwise, symmetric, fixed iteration count, and clamped so every stone
+    stays on the tile with its bound inside the edge.
+    &quot;&quot;&quot;</span>
+    pts = [Vector((x, y)) <span class="k">for</span> x, y <span class="k">in</span> specs]
+    need = <span class="n">2.0</span> * STONE_R_BOUND + STONE_CLEAR
+    lim = half_span - STONE_R_BOUND - STONE_CLEAR
+    <span class="k">for</span> _ <span class="k">in</span> range(RELAX_ITERS):
+        moved = <span class="k">False</span>
+        <span class="k">for</span> i <span class="k">in</span> range(len(pts)):
+            <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(pts)):
+                d = pts[j] - pts[i]
+                dist = d.length
+                <span class="k">if</span> dist &gt;= need:
+                    <span class="k">continue</span>
+                <span class="k">if</span> dist &lt; <span class="n">1e-9</span>:
+                    d = Vector((<span class="n">1.0</span>, <span class="n">0.0</span>))
+                    dist = <span class="n">1e-9</span>
+                push = d / dist * (<span class="n">0.5</span> * (need - dist))
+                pts[i] -= push
+                pts[j] += push
+                moved = <span class="k">True</span>
+        <span class="k">for</span> p <span class="k">in</span> pts:
+            p.x = max(-lim, min(lim, p.x))
+            p.y = max(-lim, min(lim, p.y))
+        <span class="k">if</span> <span class="k">not</span> moved:
+            <span class="k">break</span>
+    <span class="k">return</span> [(p.x, p.y) <span class="k">for</span> p <span class="k">in</span> pts]
+
+
+<span class="k">def</span> masonry_from_cubes(bm, box_rocks=<span class="k">False</span>, poke=<span class="k">False</span>, float_up=<span class="k">False</span>, pile=<span class="k">False</span>):
     stone_faces = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> f.material_index == STONE_IDX]
     visited = set()
     islands = []
@@ -784,6 +854,20 @@ <h2>Source</h2>
 
     bm.verts.ensure_lookup_table()
     bm.faces.ensure_lookup_table()
+    dirt_xy = [v.co <span class="k">for</span> v <span class="k">in</span> bm.verts]
+    span_c = (
+        <span class="n">0.5</span> * (min(c.x <span class="k">for</span> c <span class="k">in</span> dirt_xy) + max(c.x <span class="k">for</span> c <span class="k">in</span> dirt_xy)),
+        <span class="n">0.5</span> * (min(c.y <span class="k">for</span> c <span class="k">in</span> dirt_xy) + max(c.y <span class="k">for</span> c <span class="k">in</span> dirt_xy)),
+    )
+    local = [(x - span_c[<span class="n">0</span>], y - span_c[<span class="n">1</span>]) <span class="k">for</span> x, y <span class="k">in</span> specs]
+    <span class="k">if</span> pile:
+        <span class="c"># Falsifier: no relaxation, and the scatter drawn in toward the</span>
+        <span class="c"># middle so neighbours collide. Skipping relaxation alone proves</span>
+        <span class="c"># nothing once the stones are cleaved small enough to miss.</span>
+        local = [(x * PILE_PULL, y * PILE_PULL) <span class="k">for</span> x, y <span class="k">in</span> local]
+    <span class="k">else</span>:
+        local = relax_centres(local, PATCH / <span class="n">2.0</span>)
+    specs = [(x + span_c[<span class="n">0</span>], y + span_c[<span class="n">1</span>]) <span class="k">for</span> x, y <span class="k">in</span> local]
     <span class="k">for</span> cx, cy <span class="k">in</span> specs:
         dirt_z = nearest_dirt_z(bm, cx, cy)
         add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up)
@@ -797,6 +881,7 @@ <h2>Source</h2>
     box_rocks=<span class="k">False</span>,
     poke=<span class="k">False</span>,
     float_up=<span class="k">False</span>,
+    pile=<span class="k">False</span>,
 ):
     carrier = bpy.data.meshes.new(name + <span class="s">&quot;Carrier&quot;</span>)
     carrier.vertices.add(<span class="n">1</span>)
@@ -817,7 +902,7 @@ <h2>Source</h2>
         slabify(bm, floor_z=<span class="n">0.0</span>)
         bm.verts.ensure_lookup_table()
         bm.faces.ensure_lookup_table()
-        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up)
+        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up, pile=pile)
         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]
         zs = [v.co.z <span class="k">for</span> v <span class="k">in</span> bm.verts]
@@ -835,13 +920,15 @@ <h2>Source</h2>
             bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        <span class="c"># Broken rock is faceted; smooth shading made the cleaved stones</span>
+        <span class="c"># read as eggs again. Nothing on this tile is smooth-shaded.</span>
         <span class="k">for</span> face <span class="k">in</span> bm.faces:
-            face.smooth = face.material_index == STONE_IDX
+            face.smooth = <span class="k">False</span>
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         <span class="k">for</span> poly <span class="k">in</span> me.polygons:
-            poly.use_smooth = poly.material_index == STONE_IDX
+            poly.use_smooth = <span class="k">False</span>
     <span class="k">finally</span>:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -871,6 +958,67 @@ <h2>Source</h2>
     <span class="k">return</span> mat
 
 
+<span class="k">def</span> _sock(sockets, identifier):
+    <span class="s">&quot;&quot;&quot;A Mix-node socket by identifier; its A/B/Result names repeat per type.&quot;&quot;&quot;</span>
+    <span class="k">return</span> next(sk <span class="k">for</span> sk <span class="k">in</span> sockets <span class="k">if</span> sk.identifier == identifier)
+
+
+<span class="k">def</span> mottled(name, dark, light, rough_lo, rough_hi, scale, fine, bump):
+    <span class="s">&quot;&quot;&quot;Object-space mottle for colour, fine noise for roughness and bump.&quot;&quot;&quot;</span>
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = <span class="k">True</span>
+    nt = mat.node_tree
+    bsdf = nt.nodes[<span class="s">&quot;Principled BSDF&quot;</span>]
+    coord = nt.nodes.new(<span class="s">&quot;ShaderNodeTexCoord&quot;</span>)
+    big = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    big.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = scale
+    big.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">5.0</span>
+    big.inputs[<span class="s">&quot;Roughness&quot;</span>].default_value = <span class="n">0.6</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], big.inputs[<span class="s">&quot;Vector&quot;</span>])
+    ramp = nt.nodes.new(<span class="s">&quot;ShaderNodeValToRGB&quot;</span>)
+    ramp.color_ramp.elements[<span class="n">0</span>].position = <span class="n">0.30</span>
+    ramp.color_ramp.elements[<span class="n">0</span>].color = dark
+    ramp.color_ramp.elements[<span class="n">1</span>].position = <span class="n">0.72</span>
+    ramp.color_ramp.elements[<span class="n">1</span>].color = light
+    nt.links.new(big.outputs[<span class="s">&quot;Fac&quot;</span>], ramp.inputs[<span class="s">&quot;Fac&quot;</span>])
+    nt.links.new(ramp.outputs[<span class="s">&quot;Color&quot;</span>], bsdf.inputs[<span class="s">&quot;Base Color&quot;</span>])
+    small = nt.nodes.new(<span class="s">&quot;ShaderNodeTexNoise&quot;</span>)
+    small.inputs[<span class="s">&quot;Scale&quot;</span>].default_value = fine
+    small.inputs[<span class="s">&quot;Detail&quot;</span>].default_value = <span class="n">3.0</span>
+    nt.links.new(coord.outputs[<span class="s">&quot;Object&quot;</span>], small.inputs[<span class="s">&quot;Vector&quot;</span>])
+    rough = nt.nodes.new(<span class="s">&quot;ShaderNodeMapRange&quot;</span>)
+    rough.inputs[<span class="s">&quot;To Min&quot;</span>].default_value = rough_lo
+    rough.inputs[<span class="s">&quot;To Max&quot;</span>].default_value = rough_hi
+    nt.links.new(small.outputs[<span class="s">&quot;Fac&quot;</span>], rough.inputs[<span class="s">&quot;Value&quot;</span>])
+    nt.links.new(rough.outputs[<span class="s">&quot;Result&quot;</span>], bsdf.inputs[<span class="s">&quot;Roughness&quot;</span>])
+    <span class="k">if</span> bump &gt; <span class="n">0.0</span>:
+        bmp = nt.nodes.new(<span class="s">&quot;ShaderNodeBump&quot;</span>)
+        bmp.inputs[<span class="s">&quot;Strength&quot;</span>].default_value = bump
+        bmp.inputs[<span class="s">&quot;Distance&quot;</span>].default_value = <span class="n">0.003</span>
+        nt.links.new(small.outputs[<span class="s">&quot;Fac&quot;</span>], bmp.inputs[<span class="s">&quot;Height&quot;</span>])
+        nt.links.new(bmp.outputs[<span class="s">&quot;Normal&quot;</span>], bsdf.inputs[<span class="s">&quot;Normal&quot;</span>])
+    <span class="k">return</span> mat
+
+
+<span class="k">def</span> terrain_materials():
+    <span class="s">&quot;&quot;&quot;(dirt, stone): shared by the check, the render and inspection.
+
+    The old pale tan dirt and near-white stone read as a clay slab with
+    marshmallows on it. Dark mottled soil and grey weathered stone give
+    the value contrast the other way round: stones lighter than the ground
+    but not white, the ground earth rather than clay.
+    &quot;&quot;&quot;</span>
+    dirt = mottled(
+        <span class="s">&quot;TerrainDirt&quot;</span>, (<span class="n">0.075</span>, <span class="n">0.048</span>, <span class="n">0.026</span>, <span class="n">1.0</span>), (<span class="n">0.20</span>, <span class="n">0.135</span>, <span class="n">0.075</span>, <span class="n">1.0</span>),
+        <span class="n">0.82</span>, <span class="n">0.98</span>, scale=<span class="n">6.0</span>, fine=<span class="n">90.0</span>, bump=<span class="n">0.35</span>,
+    )
+    stone = mottled(
+        <span class="s">&quot;TerrainStone&quot;</span>, (<span class="n">0.20</span>, <span class="n">0.195</span>, <span class="n">0.18</span>, <span class="n">1.0</span>), (<span class="n">0.40</span>, <span class="n">0.38</span>, <span class="n">0.34</span>, <span class="n">1.0</span>),
+        <span class="n">0.62</span>, <span class="n">0.86</span>, scale=<span class="n">9.0</span>, fine=<span class="n">160.0</span>, bump=<span class="n">0.20</span>,
+    )
+    <span class="k">return</span> dirt, stone
+
+
 <span class="k">def</span> assign_slots(obj, dirt, stone):
     <span class="c"># Do not materials.clear() — that resets polygon material_index to 0</span>
     <span class="c"># on this Blender, which would drop stone faces onto dirt.</span>
@@ -1154,6 +1302,29 @@ <h2>Source</h2>
     }
 
 
+<span class="k">def</span> stone_overlap_audit(me):
+    <span class="s">&quot;&quot;&quot;Pairs of stone shells whose surfaces interpenetrate (BVH overlap).&quot;&quot;&quot;</span>
+    trees = []
+    <span class="k">for</span> g <span class="k">in</span> shells(me):
+        <span class="k">if</span> mat_of(me, g) != STONE_IDX:
+            <span class="k">continue</span>
+        bm = bmesh.new()
+        <span class="k">try</span>:
+            bm.from_mesh(me)
+            keep = set(g)
+            drop = [f <span class="k">for</span> f <span class="k">in</span> bm.faces <span class="k">if</span> <span class="k">not</span> all(v.index <span class="k">in</span> keep <span class="k">for</span> v <span class="k">in</span> f.verts)]
+            bmesh.ops.delete(bm, geom=drop, context=<span class="s">&quot;FACES&quot;</span>)
+            trees.append(BVHTree.FromBMesh(bm))
+        <span class="k">finally</span>:
+            bm.free()
+    pairs = <span class="n">0</span>
+    <span class="k">for</span> i <span class="k">in</span> range(len(trees)):
+        <span class="k">for</span> j <span class="k">in</span> range(i + <span class="n">1</span>, len(trees)):
+            <span class="k">if</span> trees[i].overlap(trees[j]):
+                pairs += <span class="n">1</span>
+    <span class="k">return</span> pairs
+
+
 <span class="k">def</span> check(
     skip_decimate,
     lift_z=<span class="k">False</span>,
@@ -1161,17 +1332,11 @@ <h2>Source</h2>
     poke=<span class="k">False</span>,
     float_up=<span class="k">False</span>,
     box_rocks=<span class="k">False</span>,
+    pile=<span class="k">False</span>,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=<span class="k">True</span>)
-    dirt = principled(
-        <span class="s">&quot;TerrainDirt&quot;</span>, (<span class="n">0.30</span>, <span class="n">0.17</span>, <span class="n">0.07</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.90</span>,
-        noise_scale=<span class="n">14.0</span>, wear=(<span class="n">0.18</span>, <span class="n">0.10</span>, <span class="n">0.04</span>, <span class="n">1.0</span>),
-    )
-    stone = principled(
-        <span class="s">&quot;TerrainStone&quot;</span>, (<span class="n">0.56</span>, <span class="n">0.53</span>, <span class="n">0.48</span>, <span class="n">1.0</span>), <span class="n">0.0</span>, <span class="n">0.76</span>,
-        noise_scale=<span class="n">20.0</span>, wear=(<span class="n">0.38</span>, <span class="n">0.35</span>, <span class="n">0.30</span>, <span class="n">1.0</span>),
-    )
-    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up)
+    dirt, stone = terrain_materials()
+    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up, pile=pile)
     low = build_terrain_mesh(<span class="s">&quot;TerrainLow&quot;</span>, <span class="n">21</span>, dirt, stone, **kw)
     high = build_terrain_mesh(<span class="s">&quot;TerrainHigh&quot;</span>, <span class="n">25</span>, dirt, stone, **kw)
     assign_slots(low, dirt, stone)
@@ -1229,6 +1394,10 @@ <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 points TMPDIR at its own temp preference, which on a portable</span>
+    <span class="c"># build is the working directory, so the export must not outlive this.</span>
+    <span class="k">if</span> os.path.isfile(export_path):
+        os.remove(export_path)
 
     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>)
     print(
@@ -1250,6 +1419,7 @@ <h2>Source</h2>
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
     jnt = joint_audit(low.data)
+    overlaps = stone_overlap_audit(low.data)
     print(
         <span class="s">f&quot;</span><span class="s">measured 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>
@@ -1257,7 +1427,8 @@ <h2>Source</h2>
     )
     print(
         <span class="s">f&quot;</span><span class="s">measured stones=</span>{jnt[<span class="s">&#x27;n_stones&#x27;</span>]}<span class="s"> min_faces=</span>{jnt[<span class="s">&#x27;min_faces&#x27;</span>]}<span class="s"> </span><span class="s">&quot;</span>
-        <span class="s">f&quot;</span><span class="s">poke_z=</span>{jnt[<span class="s">&#x27;poke_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> float_off=</span>{jnt[<span class="s">&#x27;float_off&#x27;</span>]:<span class="s">.5f</span>}<span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">poke_z=</span>{jnt[<span class="s">&#x27;poke_z&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> float_off=</span>{jnt[<span class="s">&#x27;float_off&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> </span><span class="s">&quot;</span>
+        <span class="s">f&quot;</span><span class="s">stone_overlaps=</span>{overlaps}<span class="s">&quot;</span>
     )
 
     <span class="k">if</span> jnt[<span class="s">&quot;min_faces&quot;</span>] &lt; STONE_SHELL_FACES_MIN:
@@ -1300,6 +1471,11 @@ <h2>Source</h2>
             <span class="s">f&quot;</span><span class="s">float_off </span>{jnt[<span class="s">&#x27;float_off&#x27;</span>]:<span class="s">.5f</span>}<span class="s"> &gt; </span>{ROCK_SEAT_MAX}<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>
+    <span class="k">if</span> overlaps:
+        <span class="k">return</span> fail(
+            <span class="s">f&quot;</span>{overlaps}<span class="s"> stone pairs interpenetrate (--pile-rocks is the designed fail)</span><span class="s">&quot;</span>,
+            <span class="n">20</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> bb[<span class="n">2</span>] &gt; ZMIN_EPS:
         <span class="k">return</span> fail(<span class="s">f&quot;</span><span class="s">grounded zmin=</span>{bb[<span class="n">2</span>]:<span class="s">.5f</span>}<span class="s">&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> (
@@ -1464,6 +1640,7 @@ <h2>Source</h2>
     p.add_argument(<span class="s">&quot;--poke-rock&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--float-rocks&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     p.add_argument(<span class="s">&quot;--box-rocks&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
+    p.add_argument(<span class="s">&quot;--pile-rocks&quot;</span>, action=<span class="s">&quot;store_true&quot;</span>)
     args = p.parse_args(argv)
 
     code, low, _high, dirt, tex, _col = check(
@@ -1473,6 +1650,7 @@ <h2>Source</h2>
         poke=args.poke_rock,
         float_up=args.float_rocks,
         box_rocks=args.box_rocks,
+        pile=args.pile_rocks,
     )
     <span class="k">if</span> code:
         <span class="k">return</span> code
@@ -1497,7 +1675,7 @@ <h2>Source</h2>
   </main>
   <dialog class="lightbox" id="lightbox" aria-label="Full-size render">
     <button class="lightbox-close" type="button" autofocus>Close</button>
-    <img src="../assets/terrain-scatter-hero.webp" alt="A square tile of sandy rolling terrain with pale rocks scattered on the hill." />
+    <img src="../assets/terrain-scatter-hero.webp" alt="A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching." />
   </dialog>
   <footer>
     <div class="statusbar">
diff --git a/examples/export-preset-axis/export_preset_axis.py b/examples/export-preset-axis/export_preset_axis.py
index 94dd01f8..de398a15 100644
--- a/examples/export-preset-axis/export_preset_axis.py
+++ b/examples/export-preset-axis/export_preset_axis.py
@@ -391,8 +391,10 @@ def render_still(source, unity_objs, godot_objs, path, engine):
     scene = bpy.context.scene
     source.hide_render = True
     source.hide_viewport = True
-    sit_on_floor(unity_objs, -2.15, 0.0)
-    sit_on_floor(godot_objs, 1.95, 0.0)
+    # Closer together: at -2.15 / +1.95 the pair left an empty metre of floor
+    # between them, and each prop was small in its half of the frame.
+    sit_on_floor(unity_objs, -1.35, 0.0)
+    sit_on_floor(godot_objs, 1.35, 0.0)
 
     floor_me = bpy.data.meshes.new("Floor")
     bm = bmesh.new()
@@ -428,10 +430,14 @@ def render_still(source, unity_objs, godot_objs, path, engine):
     cam_data = bpy.data.cameras.new("Cam")
     cam_data.lens = 50.0
     cam = bpy.data.objects.new("Cam", cam_data)
-    cam.location = (3.12, -8.15, 2.45)
+    # Oblique rather than straight down +Y: the Godot reimport lies with its
+    # mast along -Y, and a camera looking along Y foreshortened that mast to
+    # a stub in front of the base plate, so the one thing the check proves
+    # (it lies) barely read. From the side-front the mast shows its length.
+    cam.location = (4.9, -5.1, 2.2)
     scene.collection.objects.link(cam)
     aim = bpy.data.objects.new("Aim", None)
-    aim.location = (0.0, 0.0, 0.85)
+    aim.location = (0.40, -0.30, 1.00)
     scene.collection.objects.link(aim)
     con = cam.constraints.new("TRACK_TO")
     con.target = aim
diff --git a/examples/export-preset-axis/preview.webp b/examples/export-preset-axis/preview.webp
index f38c681d..fcb7f906 100644
Binary files a/examples/export-preset-axis/preview.webp and b/examples/export-preset-axis/preview.webp differ
diff --git a/examples/mesh-automasking-settings/README.md b/examples/mesh-automasking-settings/README.md
index d8048650..54257170 100644
--- a/examples/mesh-automasking-settings/README.md
+++ b/examples/mesh-automasking-settings/README.md
@@ -18,7 +18,7 @@ with `bpy.data.brushes.new("ProbeBrush", mode="SCULPT")`. `mode="SCULPT"`
 is load-bearing on 5.2: a default-mode `new(name)` leaves
 `mesh_automasking_settings is None`.
 
-**Subset** (not all 18+ attributes): `use_automasking_topology` and
+**Subset** (3 of the 18 attributes; the full map is below): `use_automasking_topology` and
 `use_automasking_cavity` keep their identifiers after the move; cavity
 factor does not (`Brush.automasking_cavity_factor` vs
 `MeshAutomaskingSettings.cavity_factor`). That pair covers the location
@@ -46,6 +46,89 @@ every binary.
 
 No `SMOKE_SKIP`. Every matrix leg exercises the contract.
 
+## Who hits this
+
+Sculpt add-ons, brush-preset importers and tool-setting UIs that read or
+write `brush.use_automasking_*` / `brush.automasking_*`. On 5.2 the first
+such access raises `AttributeError: 'Brush' object has no attribute ...`.
+A panel that draws it disappears from the UI, and an importer stops
+halfway through a preset.
+
+Two traps on the way to fixing it:
+
+- **The prefix rule is not uniform.** The ten `use_automasking_*`
+  booleans keep their identifiers on the new struct. The eight
+  `automasking_*` values drop the prefix, so a blanket
+  `getattr(mas, old_name)` port breaks on exactly those eight.
+- **A brush made without a mode has no settings struct.**
+  `bpy.data.brushes.new(name)` returns a brush whose
+  `mesh_automasking_settings` is `None` on 5.2. It must be created with
+  `mode="SCULPT"`. A reader that trusts the pointer then dereferences
+  `None`.
+
+The version-safe reader is the one this example asserts
+(`read_current`): take `.mesh_automasking_settings` when it exists and is
+not `None`, otherwise fall back to the `Brush` attributes. Writes go
+through the same struct and round-trip: setting `cavity_factor` and
+`use_automasking_topology` on it reads back unchanged on 5.2.1.
+
+## Full attribute map
+
+Measured by listing `Brush` RNA on 4.5.11 and 5.1.2 (18 automasking
+properties, identical on both), and `MeshAutomaskingSettings` RNA on 5.2.1
+(19 properties).
+
+| 4.5 / 5.1 `Brush.` | 5.2 `Brush.mesh_automasking_settings.` |
+| --- | --- |
+| `use_automasking_topology` | `use_automasking_topology` |
+| `use_automasking_face_sets` | `use_automasking_face_sets` |
+| `use_automasking_boundary_edges` | `use_automasking_boundary_edges` |
+| `use_automasking_boundary_face_sets` | `use_automasking_boundary_face_sets` |
+| `use_automasking_cavity` | `use_automasking_cavity` |
+| `use_automasking_cavity_inverted` | `use_automasking_cavity_inverted` |
+| `use_automasking_custom_cavity_curve` | `use_automasking_custom_cavity_curve` |
+| `use_automasking_start_normal` | `use_automasking_start_normal` |
+| `use_automasking_view_normal` | `use_automasking_view_normal` |
+| `use_automasking_view_occlusion` | `use_automasking_view_occlusion` |
+| `automasking_boundary_edges_propagation_steps` | `boundary_edges_propagation_steps` |
+| `automasking_cavity_blur_steps` | `cavity_blur_steps` |
+| `automasking_cavity_curve` | `cavity_curve` |
+| `automasking_cavity_factor` | `cavity_factor` |
+| `automasking_start_normal_falloff` | `start_normal_falloff` |
+| `automasking_start_normal_limit` | `start_normal_limit` |
+| `automasking_view_normal_falloff` | `view_normal_falloff` |
+| `automasking_view_normal_limit` | `view_normal_limit` |
+| — | `cavity_curve_op` (new in 5.2, no Brush counterpart) |
+
+On 5.2.1 the only automasking-named property left on `Brush` is the
+`mesh_automasking_settings` pointer itself.
+
+## Re-verified
+
+| Measurement | 4.5.11 | 5.1.2 | 5.2.1 |
+| --- | --- | --- | --- |
+| `bpy.types.MeshAutomaskingSettings` exists | no | no | yes |
+| Automasking properties on `Brush` | 18 | 18 | 1 (the pointer) |
+| `mesh_automasking_settings`, `mode="SCULPT"` | no attribute | no attribute | struct |
+| `mesh_automasking_settings`, default mode | no attribute | no attribute | `None` |
+| Brushes in factory-empty | 0 | 0 | 0 |
+| default exit | 0 | 0 | 0 |
+| `--assume-brush-attrs` exit | 0 | 0 | 5 |
+
+Exiting 0 on 4.5.11 and 5.1.2 under the falsifier is correct by design.
+The old attributes still exist there, so the naive read works; the
+falsifier exists to fail where they were removed.
+
+## API reference
+
+- [`bpy.types.MeshAutomaskingSettings`](https://docs.blender.org/api/current/bpy.types.MeshAutomaskingSettings.html)
+  (5.2 only)
+- [`bpy.types.Brush`](https://docs.blender.org/api/current/bpy.types.Brush.html)
+  ([4.5 LTS](https://docs.blender.org/api/4.5/bpy.types.Brush.html), where
+  the `use_automasking_*` / `automasking_*` attributes live)
+- [`BlendDataBrushes.new`](https://docs.blender.org/api/current/bpy.types.BlendDataBrushes.html#bpy.types.BlendDataBrushes.new)
+  — the `mode` argument
+
 ## Run
 
 ```bash
diff --git a/showcase/README.md b/showcase/README.md
index e9bcdab8..dfb3083a 100644
--- a/showcase/README.md
+++ b/showcase/README.md
@@ -53,7 +53,8 @@ entry in `showcase/gallery.json`, and a rendered still.
   `--float-nails` lifts nail heads off their strap (exit 18).
   `--short-mortar` stops every mortar joint shy of its stones (exit 18).
   `--open-ends` restores open U-band ends so the water is not contained
-  (exit 18).
+  (exit 18). `--pile-rocks` draws scattered stones together so they
+  interpenetrate (file-local code; `terrain-scatter` uses 20).
   `--sharp-iron` skips a chamfer pass so the edge-treatment budget fails
   (file-local code; `crate-stack` uses 21).
   A budget with no falsifier witnesses nothing:
@@ -349,6 +350,19 @@ entry in `showcase/gallery.json`, and a rendered still.
   exposed face of the contents — perimeter **and** interior points, since
   a rim band covers the perimeter only — and require every ray to hit the
   vessel within a named reach. `--open-ends` is the falsifier.
+- **Scattered parts do not interpenetrate (file-local code).** Jittered
+  scatter pushes neighbours into each other, and nothing else in the
+  hygiene family compares one scattered part with another. BVH-test every
+  pair and assert **0** overlaps. Space the parts structurally: relax
+  their centres apart to twice a radius bound **derived** from the same
+  constants that size them, so scaling the parts widens the spacing too.
+  A falsifier that only skips the relaxation proves nothing if the parts
+  happen to miss anyway; `terrain-scatter`'s `--pile-rocks` also draws
+  the scatter inward so collisions are guaranteed.
+- **Rock is broken, not smooth.** A smooth-shaded ellipsoid is an egg.
+  Cleave it with a few closed-form planes (project every vertex beyond a
+  plane onto it) and shade it flat, so it reads as broken stone. Cleaving
+  takes volume off, so re-check scale against the host afterwards.
 - **Keep a falsifier's envelope still.** A falsifier that moves the
   support the piece grounds on re-grounds the whole piece and moves the
   AABB with it. `water-trough`'s `--short-legs` lifted the shoes; the
diff --git a/showcase/gallery.json b/showcase/gallery.json
index 24e5c2be..3fb97d46 100644
--- a/showcase/gallery.json
+++ b/showcase/gallery.json
@@ -102,7 +102,7 @@
       "name": "terrain-scatter",
       "dir": "showcase/terrain-scatter",
       "teaches": "A Geometry Nodes hill tile with seated icosphere scatter through UVs, bake, LOD, collider, and Unity glTF, asserting recomputed budgets rather than an API contract.",
-      "alt": "A square tile of sandy rolling terrain with pale rocks scattered on the hill.",
+      "alt": "A square tile of dark rolling earth with nine faceted grey rocks seated across the hill, none touching.",
       "witnessesFix": "Recomputed: 1758 tris, two materials with 720 stone faces, UVs in 0..1 with zero AABB overlap, outer AABB 1.800×1.800×0.552 m, grounded zmin, 9 stones of ≥80 faces seated on sampled dirt Z (offset −35 mm, floor zmin 0.113 m), LOD ratios in band, convex collider 81 tris, hygiene zero, non-empty glTF. --skip-decimate exits 9; --stray-vert 15; --lift-z 16; --poke-rock 17; --float-rocks 18; --box-rocks 19.",
       "hero": "docs/gallery/assets/terrain-scatter-hero.webp",
       "preview": "showcase/terrain-scatter/preview.webp",
diff --git a/showcase/terrain-scatter/README.md b/showcase/terrain-scatter/README.md
index 1a77db23..fcb26e80 100644
--- a/showcase/terrain-scatter/README.md
+++ b/showcase/terrain-scatter/README.md
@@ -2,7 +2,7 @@
 
 A showcase piece, not an example. Geometry Nodes sine-hill Mesh Grid
 with an Index-jittered Instance-on-Points scatter, realized cubes
-replaced by closed-form displaced icospheres seated on sampled dirt Z,
+replaced by closed-form cleaved, faceted stones seated on sampled dirt Z,
 then the shipped pipeline: unique-cell UVs, Cycles high-to-low normal
 bake, LOD chain, convex collider, Unity glTF export.
 
@@ -24,7 +24,7 @@ imported as a package). Hygiene combinatorics match
 `examples/mesh-hygiene-audit` (copied, not imported).
 
 Intended size: 1.80 m square hill tile, ~0.16 m sine amplitude, nine
-seated stones; outer AABB 1.800 × 1.800 × 0.552 m.
+seated stones; outer AABB 1.800 × 1.800 × 0.584 m.
 
 ## Budgets
 
@@ -38,9 +38,9 @@ materials, UVs, evaluated LOD, collider, or export file.
 | LOD2 ratio | 0.10–0.35 of base | 0.2196 / 0.2196 / 0.2196 |
 | Materials | exactly 2 distinct, ≥24 stone faces | 2 slots, 720 stone |
 | UVs | in `0..1`, AABB overlap ≤ 1e-5 | in range, overlap 0 |
-| Outer AABB | (1.800, 1.800, 0.552) m ± 0.015 | (1.8000, 1.8000, 0.5523), zmin 0 |
-| Collider tris | ≤ 120 | 81 |
-| Export | written, size > 0 | 158156 / 158156 / 158140 bytes |
+| Outer AABB | (1.800, 1.800, 0.584) m ± 0.015 | (1.8000, 1.8000, 0.5838), zmin 0 |
+| Collider tris | ≤ 120 | 72 |
+| Export | written, size > 0 | 157476 / 157476 / 157460 bytes |
 
 Base triangles rose from **1194 to 1758** in the quality pass: 9-vert hill
 became a 21-vert grid, and bevelled cubes became subdiv-2 icospheres.
@@ -51,7 +51,8 @@ DECIMATE COLLAPSE triangle counts are **not** guaranteed identical across
 series — the gate is a ratio band, not an exact count. This mesh matched
 on 4.5.11 / 5.1.2 / 5.2.1. Bake pixels are stochastic; the gate is
 `has_data` plus operator `FINISHED`, not byte-identity. Construction uses
-no RNG. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not
+no RNG: jitter, cleave planes and relaxation are all closed form or fixed
+iteration. Export byte counts differ by 16 B on 5.2.1 (glTF serializer), not
 a gated axis.
 
 ### Hygiene
@@ -69,8 +70,39 @@ Recomputed from the generated mesh, not asserted about the script.
 | Grounded: `zmin` | within 1e-4 of 0 | 0.0000 |
 | Stone shells | 9 | 9 |
 | Per-stone faces | ≥ 40 | 80 |
-| Stone floor `zmin` | ≥ 0.012 m | 0.11334 |
-| Seat offset (`zmin` − dirt Z) | ≤ 0.02 m | −0.03500 |
+| Stone floor `zmin` | ≥ 0.012 m | 0.11112 |
+| Seat offset (`zmin` − dirt Z) | ≤ 0.02 m | −0.00745 |
+| Interpenetrating stone pairs (BVH overlap) | 0 | 0 |
+
+### Why the stones are cleaved, relaxed and faceted
+
+The committed stones were smooth-shaded, near-white ellipsoids with a
+gentle sine bump: eggs or marshmallows on a pale clay slab. Two pairs
+also interpenetrated, because the GN scatter jitters by up to 0.22 m on a
+0.575 m grid, and no budget compared stone to stone.
+
+- **Cleaved.** Each ellipsoid is cut by `N_CLEAVES` planes whose normals
+  and depths come from the stone's own centre, closed form. Every vertex
+  beyond a plane is projected onto it, which leaves flat broken faces.
+  Stones are shaded flat, because broken rock is faceted; smooth shading
+  turned the cleaved stones back into eggs.
+- **Scaled.** Cleaving takes about a third off each stone, and at the old
+  size they read as pebbles, so every semi-axis is `ROCK_SCALE` = 1.35×.
+- **Relaxed.** Stone centres are pushed apart to
+  `2 × STONE_R_BOUND + STONE_CLEAR` over a fixed number of symmetric
+  passes, and clamped so each stone's bound stays on the tile.
+  `STONE_R_BOUND` is derived from `ROCK_SCALE` and the largest semi-axis,
+  bump and tilt, so scaling the stones widens the spacing with them. With
+  today's numbers the unrelaxed scatter would also clear; the relaxation
+  is what keeps that true when the scatter or the sizes change.
+- **Materials.** Dark mottled soil and grey weathered stone, with
+  roughness and a small bump from fine object-space noise.
+
+`stone_overlap_audit` BVH-tests every stone pair. `--pile-rocks` skips
+the relaxation and draws the scatter in to 40% so neighbours collide: 6
+pairs interpenetrate on 5.2.1, and the piece exits 20. Skipping the
+relaxation alone would prove nothing, because the cleaved stones miss
+each other unrelaxed.
 
 ### Falsifiers
 
@@ -85,6 +117,7 @@ and returned the same code on each.
 | `--poke-rock` | stone floor `zmin` | 17 |
 | `--float-rocks` | seat offset vs sampled dirt Z | 18 |
 | `--box-rocks` | per-stone face floor | 19 |
+| `--pile-rocks` | stone-to-stone interpenetration is 0 | 20 |
 
 ## Run
 
@@ -96,6 +129,7 @@ blender --background --python terrain_scatter.py -- --lift-z
 blender --background --python terrain_scatter.py -- --poke-rock
 blender --background --python terrain_scatter.py -- --float-rocks
 blender --background --python terrain_scatter.py -- --box-rocks
+blender --background --python terrain_scatter.py -- --pile-rocks
 blender --background --python terrain_scatter.py -- --output terrain.png
 ```
 
@@ -129,3 +163,4 @@ hygiene and joint-fit family.
 | 17 | Stone floor poke (`--poke-rock`) |
 | 18 | Float above host (`--float-rocks`) |
 | 19 | Stone shell faces (`--box-rocks`) |
+| 20 | Stone pairs interpenetrate (`--pile-rocks`) |
diff --git a/showcase/terrain-scatter/preview.webp b/showcase/terrain-scatter/preview.webp
index 8e728664..1baf7c96 100644
Binary files a/showcase/terrain-scatter/preview.webp and b/showcase/terrain-scatter/preview.webp differ
diff --git a/showcase/terrain-scatter/terrain_scatter.py b/showcase/terrain-scatter/terrain_scatter.py
index 6ba8615d..0d777e5f 100644
--- a/showcase/terrain-scatter/terrain_scatter.py
+++ b/showcase/terrain-scatter/terrain_scatter.py
@@ -6,14 +6,15 @@
 Unity glTF export.
 
 GN still builds the sine hill and the Index-jittered instance grid.
-Realized cubes are replaced with closed-form displaced icospheres seated
-on sampled dirt Z, then clamped above the slab floor.
+Realized cubes are replaced with closed-form cleaved, faceted stones,
+relaxed apart so no two interpenetrate, seated on sampled dirt Z, then
+clamped above the slab floor.
 
 Budgets are declared below and recomputed from the generated result.
 They are not API-contract witnesses. Each falsifier violates one named
 budget: ``--skip-decimate`` LOD, ``--stray-vert`` hygiene, ``--lift-z``
 zmin, ``--poke-rock`` stone floor, ``--float-rocks`` seat, ``--box-rocks``
-stone shell faces.
+stone shell faces, ``--pile-rocks`` stone-to-stone interpenetration.
 
 No RNG. Hills are a closed-form sine product; scatter is an Index-jittered
 instance grid. DECIMATE COLLAPSE triangle counts are not byte-identical
@@ -33,6 +34,7 @@
 import bmesh
 import bpy
 from mathutils import Euler, Vector
+from mathutils.bvhtree import BVHTree
 
 _REPO = os.path.abspath(
     os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
@@ -53,7 +55,7 @@
 N_ROCKS = 9
 
 BBOX_TOL = 0.015
-OUTER_SIZE = (1.800, 1.800, 0.552)
+OUTER_SIZE = (1.800, 1.800, 0.584)
 BASE_TRIS_MIN = 1400
 BASE_TRIS_MAX = 2800
 LOD1_RATIO_MIN = 0.32
@@ -83,6 +85,24 @@
 DIRT_IDX = 0
 STONE_IDX = 1
 
+# Stones are kept apart by relaxing their centres to at least twice a
+# bound on any stone's horizontal radius. The GN scatter jitters by up to
+# 0.22 m on a 0.575 m grid, which pushed neighbours into each other: two
+# pairs interpenetrated in the committed piece. The bound covers the
+# largest ellipsoid semi-axis (0.135), the surface bump (0.016) and the
+# lean tilt, so any two relaxed stones clear by construction.
+# Stones are ROCK_SCALE times the base ellipsoid: cleaving takes a third of
+# the volume off, and at 1.0 the cleaved stones read as pebbles on a slab.
+ROCK_SCALE = 1.35
+STONE_R_BOUND = ROCK_SCALE * (0.135 + 0.016 + 0.22 * 0.095)
+STONE_CLEAR = 0.02
+RELAX_ITERS = 40
+PILE_PULL = 0.40
+# Each rock is cleaved by a few planes through its ellipsoid, so it reads
+# as broken stone with flat faces rather than a smooth egg.
+N_CLEAVES = 5
+CLEAVE_DEPTH = 0.62
+
 
 def eevee_engine_id():
     return "BLENDER_EEVEE" if bpy.app.version >= (5, 0, 0) else "BLENDER_EEVEE_NEXT"
@@ -391,9 +411,9 @@ def nearest_dirt_z(bm, x, y):
 
 
 def add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
-    sx = 0.11 + 0.025 * math.sin(cx * 8.1)
-    sy = 0.10 + 0.022 * math.cos(cy * 6.4)
-    sz = 0.075 + 0.020 * math.sin(cx * 4.2 + cy * 3.1)
+    sx = ROCK_SCALE * (0.11 + 0.025 * math.sin(cx * 8.1))
+    sy = ROCK_SCALE * (0.10 + 0.022 * math.cos(cy * 6.4))
+    sz = ROCK_SCALE * (0.075 + 0.020 * math.sin(cx * 4.2 + cy * 3.1))
     bite = POKE_BITE if poke else ROCK_BITE
     seat = dirt_z + FLOAT_LIFT if float_up else dirt_z - bite
     rot = Euler(
@@ -413,11 +433,24 @@ def add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
         for v in verts:
             p = Vector((v.co.x * sx, v.co.y * sy, v.co.z * sz))
             if p.length > 1e-8:
-                bump = 0.016 * math.sin(p.x * 26.0 + cx * 5.0) * math.cos(
+                bump = ROCK_SCALE * 0.016 * math.sin(p.x * 26.0 + cx * 5.0) * math.cos(
                     p.y * 21.0 + cy * 4.0
                 )
                 p += p.normalized() * bump
             v.co = rot @ p
+        # Cleave: project everything beyond each plane onto it. Plane
+        # normals and depths come from the stone's own centre, closed form,
+        # so every stone breaks differently but reproducibly.
+        for k in range(N_CLEAVES):
+            a = cx * (3.7 + k) + cy * (2.3 + 1.7 * k) + 0.9 * k
+            b = 0.35 + 0.9 * (0.5 + 0.5 * math.sin(cx * 5.3 + k * 1.3 + cy))
+            n = Vector((math.cos(a) * math.sin(b), math.sin(a) * math.sin(b), math.cos(b)))
+            reach = max(abs(n.x) * sx, abs(n.y) * sy, abs(n.z) * sz)
+            d = CLEAVE_DEPTH * reach + 0.15 * reach * math.sin(cy * 7.1 + k)
+            for v in verts:
+                over = v.co.dot(n) - d
+                if over > 0.0:
+                    v.co -= n * over
         for f in {face for v in verts for face in v.link_faces}:
             f.material_index = STONE_IDX
     zmin = min(v.co.z for v in verts)
@@ -430,7 +463,39 @@ def add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up):
             v.co.z = ROCK_ZMIN
 
 
-def masonry_from_cubes(bm, box_rocks=False, poke=False, float_up=False):
+def relax_centres(specs, half_span):
+    """Push stone centres apart to 2*STONE_R_BOUND + STONE_CLEAR, deterministically.
+
+    Pairwise, symmetric, fixed iteration count, and clamped so every stone
+    stays on the tile with its bound inside the edge.
+    """
+    pts = [Vector((x, y)) for x, y in specs]
+    need = 2.0 * STONE_R_BOUND + STONE_CLEAR
+    lim = half_span - STONE_R_BOUND - STONE_CLEAR
+    for _ in range(RELAX_ITERS):
+        moved = False
+        for i in range(len(pts)):
+            for j in range(i + 1, len(pts)):
+                d = pts[j] - pts[i]
+                dist = d.length
+                if dist >= need:
+                    continue
+                if dist < 1e-9:
+                    d = Vector((1.0, 0.0))
+                    dist = 1e-9
+                push = d / dist * (0.5 * (need - dist))
+                pts[i] -= push
+                pts[j] += push
+                moved = True
+        for p in pts:
+            p.x = max(-lim, min(lim, p.x))
+            p.y = max(-lim, min(lim, p.y))
+        if not moved:
+            break
+    return [(p.x, p.y) for p in pts]
+
+
+def masonry_from_cubes(bm, box_rocks=False, poke=False, float_up=False, pile=False):
     stone_faces = [f for f in bm.faces if f.material_index == STONE_IDX]
     visited = set()
     islands = []
@@ -468,6 +533,20 @@ def masonry_from_cubes(bm, box_rocks=False, poke=False, float_up=False):
 
     bm.verts.ensure_lookup_table()
     bm.faces.ensure_lookup_table()
+    dirt_xy = [v.co for v in bm.verts]
+    span_c = (
+        0.5 * (min(c.x for c in dirt_xy) + max(c.x for c in dirt_xy)),
+        0.5 * (min(c.y for c in dirt_xy) + max(c.y for c in dirt_xy)),
+    )
+    local = [(x - span_c[0], y - span_c[1]) for x, y in specs]
+    if pile:
+        # Falsifier: no relaxation, and the scatter drawn in toward the
+        # middle so neighbours collide. Skipping relaxation alone proves
+        # nothing once the stones are cleaved small enough to miss.
+        local = [(x * PILE_PULL, y * PILE_PULL) for x, y in local]
+    else:
+        local = relax_centres(local, PATCH / 2.0)
+    specs = [(x + span_c[0], y + span_c[1]) for x, y in local]
     for cx, cy in specs:
         dirt_z = nearest_dirt_z(bm, cx, cy)
         add_seated_stone(bm, cx, cy, dirt_z, box_rocks, poke, float_up)
@@ -481,6 +560,7 @@ def build_terrain_mesh(
     box_rocks=False,
     poke=False,
     float_up=False,
+    pile=False,
 ):
     carrier = bpy.data.meshes.new(name + "Carrier")
     carrier.vertices.add(1)
@@ -501,7 +581,7 @@ def build_terrain_mesh(
         slabify(bm, floor_z=0.0)
         bm.verts.ensure_lookup_table()
         bm.faces.ensure_lookup_table()
-        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up)
+        masonry_from_cubes(bm, box_rocks=box_rocks, poke=poke, float_up=float_up, pile=pile)
         xs = [v.co.x for v in bm.verts]
         ys = [v.co.y for v in bm.verts]
         zs = [v.co.z for v in bm.verts]
@@ -519,13 +599,15 @@ def build_terrain_mesh(
             bmesh.ops.triangulate(bm, faces=ngons)
         pack_uvs(bm)
         bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        # Broken rock is faceted; smooth shading made the cleaved stones
+        # read as eggs again. Nothing on this tile is smooth-shaded.
         for face in bm.faces:
-            face.smooth = face.material_index == STONE_IDX
+            face.smooth = False
         me = bpy.data.meshes.new(name)
         bm.to_mesh(me)
         me.update()
         for poly in me.polygons:
-            poly.use_smooth = poly.material_index == STONE_IDX
+            poly.use_smooth = False
     finally:
         bm.free()
     out = bpy.data.objects.new(name, me)
@@ -555,6 +637,67 @@ def principled(name, color, metallic, roughness, noise_scale=0.0, wear=None):
     return mat
 
 
+def _sock(sockets, identifier):
+    """A Mix-node socket by identifier; its A/B/Result names repeat per type."""
+    return next(sk for sk in sockets if sk.identifier == identifier)
+
+
+def mottled(name, dark, light, rough_lo, rough_hi, scale, fine, bump):
+    """Object-space mottle for colour, fine noise for roughness and bump."""
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nt = mat.node_tree
+    bsdf = nt.nodes["Principled BSDF"]
+    coord = nt.nodes.new("ShaderNodeTexCoord")
+    big = nt.nodes.new("ShaderNodeTexNoise")
+    big.inputs["Scale"].default_value = scale
+    big.inputs["Detail"].default_value = 5.0
+    big.inputs["Roughness"].default_value = 0.6
+    nt.links.new(coord.outputs["Object"], big.inputs["Vector"])
+    ramp = nt.nodes.new("ShaderNodeValToRGB")
+    ramp.color_ramp.elements[0].position = 0.30
+    ramp.color_ramp.elements[0].color = dark
+    ramp.color_ramp.elements[1].position = 0.72
+    ramp.color_ramp.elements[1].color = light
+    nt.links.new(big.outputs["Fac"], ramp.inputs["Fac"])
+    nt.links.new(ramp.outputs["Color"], bsdf.inputs["Base Color"])
+    small = nt.nodes.new("ShaderNodeTexNoise")
+    small.inputs["Scale"].default_value = fine
+    small.inputs["Detail"].default_value = 3.0
+    nt.links.new(coord.outputs["Object"], small.inputs["Vector"])
+    rough = nt.nodes.new("ShaderNodeMapRange")
+    rough.inputs["To Min"].default_value = rough_lo
+    rough.inputs["To Max"].default_value = rough_hi
+    nt.links.new(small.outputs["Fac"], rough.inputs["Value"])
+    nt.links.new(rough.outputs["Result"], bsdf.inputs["Roughness"])
+    if bump > 0.0:
+        bmp = nt.nodes.new("ShaderNodeBump")
+        bmp.inputs["Strength"].default_value = bump
+        bmp.inputs["Distance"].default_value = 0.003
+        nt.links.new(small.outputs["Fac"], bmp.inputs["Height"])
+        nt.links.new(bmp.outputs["Normal"], bsdf.inputs["Normal"])
+    return mat
+
+
+def terrain_materials():
+    """(dirt, stone): shared by the check, the render and inspection.
+
+    The old pale tan dirt and near-white stone read as a clay slab with
+    marshmallows on it. Dark mottled soil and grey weathered stone give
+    the value contrast the other way round: stones lighter than the ground
+    but not white, the ground earth rather than clay.
+    """
+    dirt = mottled(
+        "TerrainDirt", (0.075, 0.048, 0.026, 1.0), (0.20, 0.135, 0.075, 1.0),
+        0.82, 0.98, scale=6.0, fine=90.0, bump=0.35,
+    )
+    stone = mottled(
+        "TerrainStone", (0.20, 0.195, 0.18, 1.0), (0.40, 0.38, 0.34, 1.0),
+        0.62, 0.86, scale=9.0, fine=160.0, bump=0.20,
+    )
+    return dirt, stone
+
+
 def assign_slots(obj, dirt, stone):
     # Do not materials.clear() — that resets polygon material_index to 0
     # on this Blender, which would drop stone faces onto dirt.
@@ -838,6 +981,29 @@ def joint_audit(me):
     }
 
 
+def stone_overlap_audit(me):
+    """Pairs of stone shells whose surfaces interpenetrate (BVH overlap)."""
+    trees = []
+    for g in shells(me):
+        if mat_of(me, g) != STONE_IDX:
+            continue
+        bm = bmesh.new()
+        try:
+            bm.from_mesh(me)
+            keep = set(g)
+            drop = [f for f in bm.faces if not all(v.index in keep for v in f.verts)]
+            bmesh.ops.delete(bm, geom=drop, context="FACES")
+            trees.append(BVHTree.FromBMesh(bm))
+        finally:
+            bm.free()
+    pairs = 0
+    for i in range(len(trees)):
+        for j in range(i + 1, len(trees)):
+            if trees[i].overlap(trees[j]):
+                pairs += 1
+    return pairs
+
+
 def check(
     skip_decimate,
     lift_z=False,
@@ -845,17 +1011,11 @@ def check(
     poke=False,
     float_up=False,
     box_rocks=False,
+    pile=False,
 ):
     bpy.ops.wm.read_factory_settings(use_empty=True)
-    dirt = principled(
-        "TerrainDirt", (0.30, 0.17, 0.07, 1.0), 0.0, 0.90,
-        noise_scale=14.0, wear=(0.18, 0.10, 0.04, 1.0),
-    )
-    stone = principled(
-        "TerrainStone", (0.56, 0.53, 0.48, 1.0), 0.0, 0.76,
-        noise_scale=20.0, wear=(0.38, 0.35, 0.30, 1.0),
-    )
-    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up)
+    dirt, stone = terrain_materials()
+    kw = dict(box_rocks=box_rocks, poke=poke, float_up=float_up, pile=pile)
     low = build_terrain_mesh("TerrainLow", 21, dirt, stone, **kw)
     high = build_terrain_mesh("TerrainHigh", 25, dirt, stone, **kw)
     assign_slots(low, dirt, stone)
@@ -913,6 +1073,10 @@ def check(
         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 points TMPDIR at its own temp preference, which on a portable
+    # build is the working directory, so the export must not outlive this.
+    if os.path.isfile(export_path):
+        os.remove(export_path)
 
     print(f"blender={tuple(bpy.app.version)} skip_decimate={skip_decimate}")
     print(
@@ -934,6 +1098,7 @@ def check(
     hyg = hygiene_audit(low.data)
     zf = zfight_pairs(low.data)
     jnt = joint_audit(low.data)
+    overlaps = stone_overlap_audit(low.data)
     print(
         f"measured hygiene loose_v={hyg['loose_v']} loose_e={hyg['loose_e']} "
         f"nonman={hyg['nonman']} zero_area={hyg['zero_area']} "
@@ -941,7 +1106,8 @@ def check(
     )
     print(
         f"measured stones={jnt['n_stones']} min_faces={jnt['min_faces']} "
-        f"poke_z={jnt['poke_z']:.5f} float_off={jnt['float_off']:.5f}"
+        f"poke_z={jnt['poke_z']:.5f} float_off={jnt['float_off']:.5f} "
+        f"stone_overlaps={overlaps}"
     )
 
     if jnt["min_faces"] < STONE_SHELL_FACES_MIN:
@@ -984,6 +1150,11 @@ def check(
             f"float_off {jnt['float_off']:.5f} > {ROCK_SEAT_MAX}",
             18,
         ), None, None, None, None, None
+    if overlaps:
+        return fail(
+            f"{overlaps} stone pairs interpenetrate (--pile-rocks is the designed fail)",
+            20,
+        ), None, None, None, None, None
     if bb[2] > ZMIN_EPS:
         return fail(f"grounded zmin={bb[2]:.5f}", 16), None, None, None, None, None
     if (
@@ -1148,6 +1319,7 @@ def main():
     p.add_argument("--poke-rock", action="store_true")
     p.add_argument("--float-rocks", action="store_true")
     p.add_argument("--box-rocks", action="store_true")
+    p.add_argument("--pile-rocks", action="store_true")
     args = p.parse_args(argv)
 
     code, low, _high, dirt, tex, _col = check(
@@ -1157,6 +1329,7 @@ def main():
         poke=args.poke_rock,
         float_up=args.float_rocks,
         box_rocks=args.box_rocks,
+        pile=args.pile_rocks,
     )
     if code:
         return code