fix(tools): importers clear the read-only LFS bit before saving; 0.1.3 docs refresh (#29)

Merged PR #29: v0.1.3 packaging and setup fixes

Co-authored-by: Zwitschi <zwitschi82@gmail.com>

Art/blender/hero/hero-facade-2026-11-07.json

@@ -3,18 +3,18 @@
   "frame": "project frame, metres, X east Y north Z up",
   "bounds_m": {
     "min": [
-      -13.02,
+      -13.08,
       -12.5,
       0.0
     ],
     "max": [
-      13.02,
-      0.07,
+      13.08,
+      0.13,
       14.5
     ],
     "size": [
-      26.04,
-      12.57,
+      26.16,
+      12.63,
       14.5
     ]
   },
@@ -37,6 +37,24 @@
       ],
       "evidence": "6 columns at 4.96 m centres (sibling notes x measured frontage)"
     },
+    {
+      "object": "Hero_ColumnBase_x6",
+      "dims_m": [
+        1.36,
+        1.36,
+        0.22
+      ],
+      "evidence": "assumption: Ionic base moulding; photographs show a wider base at the shaft foot"
+    },
+    {
+      "object": "Hero_Abacus_x6",
+      "dims_m": [
+        1.3,
+        1.3,
+        0.14
+      ],
+      "evidence": "assumption: square abacus under the architrave, as Ionic capitals carry"
+    },
     {
       "object": "Hero_Architrave",
       "dims_m": [
@@ -55,6 +73,15 @@
       ],
       "evidence": "assumption: projecting cornice line"
     },
+    {
+      "object": "Hero_Dentil_xN",
+      "dims_m": [
+        0.18,
+        0.3,
+        0.22
+      ],
+      "evidence": "52 dentils at 0.45 m centres under the corona; assumption: photographed cornice reads as a dentilled course"
+    },
     {
       "object": "Hero_Entablature",
       "dims_m": [
@@ -86,10 +113,10 @@
       "object": "Hero_Medallion_x2",
       "dims_m": [
         1.1,
-        1.1,
-        0.02
+        0.04,
+        1.1
       ],
-      "evidence": "photographs: two stone discs beside the motto"
+      "evidence": "photographs: two stone discs beside the motto, mounted on the parapet face"
     },
     {
       "object": "Hero_Stylobate",

Art/blender/site/export_site_fbx.py

@@ -15,6 +15,9 @@ import os
 import sys
 
 import bpy
+sys.path.insert(0, os.path.join(os.path.join(os.path.dirname(__file__), "..", "..", ".."), "Tools"))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 
 MESHES = ("Terrain_DEM", "Road_Hollywood", "Sidewalk_South", "Sidewalk_North",
           "Kerb_South", "Kerb_North", "Crossing_Markings")
@@ -60,20 +63,7 @@ def main():
             _ = bpy.context.view_layer
         bpy.context.view_layer.objects.active = obj
         path = os.path.join(args.out, name + ".fbx")
-        bpy.ops.export_scene.fbx(
-            filepath=path,
-            use_selection=True,
-            object_types={"MESH"},
-            apply_unit_scale=True,
-            apply_scale_options="FBX_SCALE_NONE",
-            axis_forward="-Y",
-            axis_up="Z",
-            use_space_transform=True,
-            use_mesh_modifiers=True,
-            mesh_smooth_type="OFF",
-            path_mode="AUTO",
-            bake_space_transform=False,
-        )
+        fbx_preset.export_static(path, selection=True)
         if mirrored:
             # The flip is an export correction, not a change to the source: undo it.
             obj.scale.y *= -1.0

CHANGELOG.md

@@ -8,127 +8,129 @@ Format: [Keep a Changelog](https://keepachangelog.com/) style, versions follow [
 
 Nothing yet.
 
-## [0.1.1] — 2026-11-08
+## [0.1.3] — 2026-11-09
 
-Collision-fidelity patch. No new scope: street geometry corrections and the QA
-tooling that measures them.
+Packaging and setup fixes. No gameplay or visual scope; this patch makes the pipeline and its documentation tell the truth about what `0.1.x` taught.
 
 ### Fixed
 
-- **Sidewalk outer edge ledge.** The sidewalk stood the full 0.15 m kerb height
-  above the DEM at both edges, leaving a 15.8 cm lip where the walk route crossed
-  from terrain onto the south sidewalk. The upstand now tapers from full at the
-  road-side edge to zero at the building-side edge; the north route's worst step
-  fell from 15.1 cm to 6.9 cm.
-- **Crossing ramps too steep.** The kerb-flush run was a fixed 1.5 m, giving
-  ~8.7 % (measured 10–13 cm over 1.5 m). The run is now derived from a target
-  grade (`--max-ramp-grade`, default 8 % ⇒ 1.63 m); the crossing steps 3.4 cm at
-  0.25 m sampling.
-
-### Added
-
-- **Walk pre-check improvements** (`Art/blender/site/site_assembly.py`): sampling
-  coverage is independent of `--sample` (it previously shrank the route), and the
-  report now prints the grade and the arc-length/offset **location** of the worst
-  step, so a step can be located rather than guessed.
+- **Map imports could report success while saving nothing.** `.umap` files are LFS-tracked and check out read-only, so `save_map()` returned `False` with no error and the staged actor vanished on the next load. New `Tools/ue_common.py` (`make_writable`, `require_saved`) clears the read-only bit and makes the failure loud; `ue_hero_facade_import.py` and `ue_import_north_buildings.py` now use it. Verified from a forced `0o444` map: chmod logged, `save_map: True`, exit 0.
 
 ### Changed
 
-- **Kerb height recorded as final** at 0.15 m modelled / 0.13 m as built — a
-  standard 6 in LA kerb; neither the 3DEP DEM nor the reference photography can
-  resolve it further (±2 cm), which is far below the character's 45 cm step
-  height.
+- `Docs/build.md`: content-pipeline table now lists every step as it exists (seven site FBXs, frontage, north buildings, hero, map) and the shared FBX preset; packaging archive corrected to `Builds/GigLineQA`; the packaged log location and `-qaselftest` usage are documented; new **traps** table covers the read-only save, the hero `--out`-is-the-FBX mistake, the MPFB add-on path, the shot actor quitting under QA, and the null-RHI trace trap.
+- `Docs/setup.md`: the fresh-checkout build is marked verified (2026-11-08) and its blocker closed; a new section documents the two optional keys (`OPENROUTER_API_KEY`, `MAPBOX_ACCESS_TOKEN`) and that neither is needed by the build, the tests or a release.
+- `Docs/Architecture/07_deployment_view.md` and the combined `architecture.md`: build-output path corrected and marked as living outside the repository.
 
 ### Verified
 
-- Site meshes rebuilt and re-imported (7/7, collision flags intact), DemoMap
-  rebuilt, packaged Development build `EXIT=0`.
-- `-qaselftest` on the packaged build: walk 761 cm in 2 s at steady Z 456, reset
-  0 cm, pause/unpause, transect 1456 samples across 16 rows / **0 holes**, wall
-  probe **0/35** blocking hits.
+- 54 tool tests pass (5 new for `ue_common`).
+- Packaged build still launches into `DemoMap` and `-qaselftest` passes every phase.
+
+## [0.1.2] — 2026-11-09
+
+Scale and façade correction patch. Buildings and the hero elevation now match the reference photography and the cross-checked height data; no new gameplay scope.
+
+### Added
+
+- **`Tools/facade_detail_concepts.py`** — generates frontal building plates (whole elevation, entrance in its façade, building with neighbours) from a local reference photograph through OpenRouter image models. Spec-driven, never overwrites, writes a provenance sidecar per image, output stays in the gitignored `Art/reference/` tree. Local working material only.
+- **`Tools/fbx_export_preset.py`** — the single FBX export preset (`ue_metric_v1` / `ue_character_v1`). Replaces the argument block that had been copied into six exporters.
+- **Façade occlusion probe** in `-qaselftest`: 40 m traces sideways from the road centre at walking height, required wherever a building is staged.
+- **Ionic detail on the hero**: base moulding at every shaft foot, a square abacus over every capital, and a 52-dentil cornice course.
+- **Tool tests**: `Tools/tests/` now covers the input driver, height classification, the Mapbox cross-check, the concept generator and the FBX preset (49 tests).
+
+### Changed
+
+- **Storey height 3.2 → 3.1 m**, calibrated against Mapbox building data, with explicit overrides for three rear outbuildings; the block cross-check now reports 66 matches and no disagreements.
+- **Hero colonnade 47.6 % → 53.1 %** of the 14.50 m elevation, inside the photographed 50–60 % band (thinner entablature and parapet).
+- Blockout regenerated at the new storey height; frontage re-exported and re-imported (6922 42.1 → 39.1 m, El Capitan Theatre 20.0 → 20.5 m).
+- FBX exports now carry smoothing groups (`FACE` instead of `OFF`), so round geometry is no longer faceted and imports stop warning.
+
+### Fixed
+
+- **Windows floated 1.44 m in front of the wall**, ahead of the colonnade; they now sit on the wall plane behind the columns.
+- **Parapet medallions were flat discs lying on the coping** instead of discs on the parapet face.
+- **The hero façade had no usable collision** — the player could walk through it. It is now complex-as-simple; auto-generated convex hulls were tried and rejected because they bulged into the street.
+- **The three "guessed" block heights were never buildings**: two `building=roof` canopies and a transit shelter. They are classified as non-building volumes and the block now reports zero guessed heights.
+
+### Verified
+
+- Packaged build `-qaselftest`: walk, reset and pause pass; seam transect 1456 samples / 0 holes; wall probe 0/35; façade probe 0/9.
+- Screenshots re-rendered for every change and approved by the owner.
 
 ### Known limitations
 
-- One residual **13.4 cm surface step at s≈198 m** on the south sidewalk (8.0 cm
-  at s≈251 m north). It is not a gap and is below the 45 cm `MaxStepHeight`, so it
-  does not block traversal; the cause is a sidewalk-strip discontinuity near a
-  centreline vertex, recorded in `Art/blender/README.md` as a smoothness
-  refinement.
-- Kerb radii at junctions, driveway aprons, drainage inlets and pavement joints
-  remain unmodelled (unchanged from `0.1.0`).
+- Cornice dentil spacing, the base and abacus dimensions are recorded assumptions: the reference photography does not resolve them at our scale.
+- Façade surfaces remain flat blockout materials; the textured pass is `0.1.4`.
+
+## [0.1.1] — 2026-11-08
+
+Collision-fidelity patch. No new scope: street geometry corrections and the QA tooling that measures them.
+
+### Fixed
+
+- **Sidewalk outer edge ledge.** The sidewalk stood the full 0.15 m kerb height above the DEM at both edges, leaving a 15.8 cm lip where the walk route crossed from terrain onto the south sidewalk. The upstand now tapers from full at the road-side edge to zero at the building-side edge; the north route's worst step fell from 15.1 cm to 6.9 cm.
+- **Crossing ramps too steep.** The kerb-flush run was a fixed 1.5 m, giving ~8.7 % (measured 10–13 cm over 1.5 m). The run is now derived from a target grade (`--max-ramp-grade`, default 8 % ⇒ 1.63 m); the crossing steps 3.4 cm at 0.25 m sampling.
+
+### Added
+
+- **Walk pre-check improvements** (`Art/blender/site/site_assembly.py`): sampling coverage is independent of `--sample` (it previously shrank the route), and the report now prints the grade and the arc-length/offset **location** of the worst step, so a step can be located rather than guessed.
+
+### Changed
+
+- **Kerb height recorded as final** at 0.15 m modelled / 0.13 m as built — a standard 6 in LA kerb; neither the 3DEP DEM nor the reference photography can resolve it further (±2 cm), which is far below the character's 45 cm step height.
+
+### Verified
+
+- Site meshes rebuilt and re-imported (7/7, collision flags intact), DemoMap rebuilt, packaged Development build `EXIT=0`.
+- `-qaselftest` on the packaged build: walk 761 cm in 2 s at steady Z 456, reset 0 cm, pause/unpause, transect 1456 samples across 16 rows / **0 holes**, wall probe **0/35** blocking hits.
+
+### Known limitations
+
+- One residual **13.4 cm surface step at s≈198 m** on the south sidewalk (8.0 cm at s≈251 m north). It is not a gap and is below the 45 cm `MaxStepHeight`, so it does not block traversal; the cause is a sidewalk-strip discontinuity near a centreline vertex, recorded in `Art/blender/README.md` as a smoothness refinement.
+- Kerb radii at junctions, driveway aprons, drainage inlets and pavement joints remain unmodelled (unchanged from `0.1.0`).
 
 Nothing yet.
 
 ## [0.1.0] — 2026-11-08
 
-The first playable release: a walkable exterior demo of the **6840 Hollywood Blvd**
-(El Capitan Entertainment Centre) block in Unreal Engine, built on OpenStreetMap
-layout data and USGS elevation, with the hero façade and the verified block
-frontage staged on a walkable street.
+The first playable release: a walkable exterior demo of the **6840 Hollywood Blvd** (El Capitan Entertainment Centre) block in Unreal Engine, built on OpenStreetMap layout data and USGS elevation, with the hero façade and the verified block frontage staged on a walkable street.
 
 ### Added
 
-- **Unreal project** (`Game/GigLine`) — C++ game module, Enhanced Input, packaged
-  Linux build, and a `DemoMap` that a plain launch opens directly.
-- **Walkable demo level** — terrain from the 3DEP DEM, Hollywood Blvd carriageway,
-  both sidewalks and kerbs with collision, the designated mid-block crossing, and
-  fixed daytime lighting (sun, sky light, sky atmosphere, height fog, pinned
-  exposure).
-- **Hero façade** for 6840 Hollywood Blvd — six-column neoclassical elevation with
-  three genuine portal recesses, entablature, parapet and motto band
-  (`Tools/hero_facade_build.py`, `Tools/ue_hero_facade_import.py`).
-- **Block frontage** — the five verified south-side neighbours (6922, 6902, 6838
-  El Capitan Theatre, 6822 Budget, 6806–6822, 6800 Lee Drug) and the two north-side
-  buildings (TCL Chinese Theatre, Madame Tussaud's) placed at their OSM positions.
-- **First-person player** — `AGigLineCharacter`: 1.75 m capsule, 1.60 m eye camera,
-  4 m/s walk, mouse look, jump, reset (`R`) and pause (`Escape`); controls
-  documented in `Docs/controls.md` and shown in-game.
-- **In-game ODbL attribution** — `AGigLineHUD` draws the OpenStreetMap credit and
-  licence line every frame.
-- **QA harness** — `-qaselftest` (walk, reset, pause, seam transect, invisible-wall
-  probe, frame-time capture) and `Tools/input_test.py` / `Tools/input_emulation.py`
-  for OS-level virtual keyboard/mouse input.
-- **Documentation** — setup, build, toolchain, licensing, ODbL review, release
-  checks, and arc42 architecture docs.
+- **Unreal project** (`Game/GigLine`) — C++ game module, Enhanced Input, packaged Linux build, and a `DemoMap` that a plain launch opens directly.
+- **Walkable demo level** — terrain from the 3DEP DEM, Hollywood Blvd carriageway, both sidewalks and kerbs with collision, the designated mid-block crossing, and fixed daytime lighting (sun, sky light, sky atmosphere, height fog, pinned exposure).
+- **Hero façade** for 6840 Hollywood Blvd — six-column neoclassical elevation with three genuine portal recesses, entablature, parapet and motto band (`Tools/hero_facade_build.py`, `Tools/ue_hero_facade_import.py`).
+- **Block frontage** — the five verified south-side neighbours (6922, 6902, 6838 El Capitan Theatre, 6822 Budget, 6806–6822, 6800 Lee Drug) and the two north-side buildings (TCL Chinese Theatre, Madame Tussaud's) placed at their OSM positions.
+- **First-person player** — `AGigLineCharacter`: 1.75 m capsule, 1.60 m eye camera, 4 m/s walk, mouse look, jump, reset (`R`) and pause (`Escape`); controls documented in `Docs/controls.md` and shown in-game.
+- **In-game ODbL attribution** — `AGigLineHUD` draws the OpenStreetMap credit and licence line every frame.
+- **QA harness** — `-qaselftest` (walk, reset, pause, seam transect, invisible-wall probe, frame-time capture) and `Tools/input_test.py` / `Tools/input_emulation.py` for OS-level virtual keyboard/mouse input.
+- **Documentation** — setup, build, toolchain, licensing, ODbL review, release checks, and arc42 architecture docs.
 
 ### Fixed
 
-- **All controls were dead in packaged and PIE builds.** The mapping-context
-  generator wrote key bindings to the deprecated `mappings` array; UE 5.8 reads
-  `DefaultKeyMappings.Mappings`, so the cooked game had zero runtime mappings and
-  every key resolved to nothing. `Tools/ue_create_input_assets.py` now populates
-  the current field.
-- **"Fall-through" was an 8 m invisible box.** `Terrain_DEM` shipped only a
-  bounding-box collision proxy; forcing complex-as-simple collision
-  (`UGigLineAssetTools`) put the player on the actual street.
-- **Reset returned the player to mid-air** — the start position is now captured on
-  the first grounded frame.
-- **Plain launch opened the engine template** — the default map now lives in
-  `DefaultEngine.ini` and points at `DemoMap`.
-- **Game target would not compile** — removed editor-only API use
-  (`UStaticMesh::PostEditChange`, `AActor::GetActorLabel`).
-- **`demo-north-buildings` screenshot** framed 85 % sky (camera 9.5 km west of the
-  buildings); re-pointed to the building mass.
+- **All controls were dead in packaged and PIE builds.** The mapping-context generator wrote key bindings to the deprecated `mappings` array; UE 5.8 reads `DefaultKeyMappings.Mappings`, so the cooked game had zero runtime mappings and every key resolved to nothing. `Tools/ue_create_input_assets.py` now populates the current field.
+- **"Fall-through" was an 8 m invisible box.** `Terrain_DEM` shipped only a bounding-box collision proxy; forcing complex-as-simple collision (`UGigLineAssetTools`) put the player on the actual street.
+- **Reset returned the player to mid-air** — the start position is now captured on the first grounded frame.
+- **Plain launch opened the engine template** — the default map now lives in `DefaultEngine.ini` and points at `DemoMap`.
+- **Game target would not compile** — removed editor-only API use (`UStaticMesh::PostEditChange`, `AActor::GetActorLabel`).
+- **`demo-north-buildings` screenshot** framed 85 % sky (camera 9.5 km west of the buildings); re-pointed to the building mass.
 
 ### Verified
 
-- Both sides of the demo are traversable: 1456-sample seam transect, 0 holes,
-  no blocking collision or invisible walls (`-qaselftest` on the packaged build).
-- Placement and street scale match the reference photography and Geo
-  measurements (road 24.3 m, sidewalk offsets 12.5/13.2 m, hero frontage 26.0 m).
-- **414 fps average / p99 3.01 ms at 2560×1440** (Epic preset, TSR, VSync off, no
-  frame generation) — far above the 60 fps target.
-- Fresh checkout builds and packages with the documented external engine
-  (UE 5.8.4).
+- Both sides of the demo are traversable: 1456-sample seam transect, 0 holes, no blocking collision or invisible walls (`-qaselftest` on the packaged build).
+- Placement and street scale match the reference photography and Geo measurements (road 24.3 m, sidewalk offsets 12.5/13.2 m, hero frontage 26.0 m).
+- **414 fps average / p99 3.01 ms at 2560×1440** (Epic preset, TSR, VSync off, no frame generation) — far above the 60 fps target.
+- Fresh checkout builds and packages with the documented external engine (UE 5.8.4).
 
 ### Known limitations
 
-- Buildings other than the hero are flat blockout volumes; façade detail,
-  materials and Blosm style scripts are planned for `0.1.4`.
-- Kerb height (0.13 m as built vs 0.15 m assumed), kerb radii, driveway aprons and
-  graded crossing ramps are deferred to `0.1.1`; crossing ramps are kerb flushes.
+- Buildings other than the hero are flat blockout volumes; façade detail, materials and Blosm style scripts are planned for `0.1.4`.
+- Kerb height (0.13 m as built vs 0.15 m assumed), kerb radii, driveway aprons and graded crossing ramps are deferred to `0.1.1`; crossing ramps are kerb flushes.
 - One block only; no vehicles, NPCs, audio, or settings UI yet.
 
-[Unreleased]: https://git.allucanget.biz/zwitschi/gig-line/compare/v0.1.1...main
+[Unreleased]: https://git.allucanget.biz/zwitschi/gig-line/compare/v0.1.3...main
+[0.1.3]: https://git.allucanget.biz/zwitschi/gig-line/releases/tag/v0.1.3
+[0.1.2]: https://git.allucanget.biz/zwitschi/gig-line/releases/tag/v0.1.2
 [0.1.1]: https://git.allucanget.biz/zwitschi/gig-line/releases/tag/v0.1.1
 [0.1.0]: https://git.allucanget.biz/zwitschi/gig-line/releases/tag/v0.1.0

Docs/Architecture/07_deployment_view.md

@@ -7,7 +7,7 @@
 | Dev workstation | Bazzite Linux 45 (Fedora 45 base, immutable ostree), Ryzen 7 7700X, 64 GB RAM, RTX 5070 Ti 16 GB, Vulkan RHI |
 | Engine install | `/run/media/system/DATA/Engines/UE_5.8.4` (73 GiB, external to repo) |
 | Project repo | `/run/media/system/DATA/Documents/06-games/gig-line` (Git + LFS, remote at `git.allucanget.biz`) |
-| Build output | `/run/media/system/DATA/Builds/GigLine` (packaged Linux build, ~1.1 GiB) |
+| Build output | `/run/media/system/DATA/Builds/GigLineQA/Linux` (packaged Development build, ~1.1 GiB; outside the repository) |
 
 Motivation  
 Single-machine development. No build farm, no CI pipeline yet. The engine, toolchain, and GPU are all on the same host.

Docs/Architecture/architecture.md

@@ -300,7 +300,7 @@ Source data: `Art/blender/` (`.blend` files), `Geo/` (OSM extracts, DEM, verific
 | Dev workstation | Bazzite Linux 45 (Fedora 45 base, immutable ostree), Ryzen 7 7700X, 64 GB RAM, RTX 5070 Ti 16 GB, Vulkan RHI |
 | Engine install | `/run/media/system/DATA/Engines/UE_5.8.4` (73 GiB, external to repo) |
 | Project repo | `/run/media/system/DATA/Documents/06-games/gig-line` (Git + LFS, remote at `git.allucanget.biz`) |
-| Build output | `/run/media/system/DATA/Builds/GigLine` (packaged Linux build, ~1.1 GiB) |
+| Build output | `/run/media/system/DATA/Builds/GigLineQA/Linux` (packaged Development build, ~1.1 GiB; outside the repository) |
 
 Motivation  
 Single-machine development. No build farm, no CI pipeline yet. The engine, toolchain, and GPU are all on the same host.

Docs/build.md

@@ -1,6 +1,6 @@
 # Build
 
-Fresh-checkout build procedure. Completed 2026-11-07 after the pinned engine was installed and a blank `Game/GigLine` build was packaged and launch-tested.
+Fresh-checkout build, content-pipeline and packaging procedure for the walkable demo. Begun 2026-11-07 from a blank build and extended through the `0.1.x` patches; the release checks that exercise it are in [release-checks.md](release-checks.md).
 
 ## Constraints
 
@@ -10,8 +10,7 @@ Fresh-checkout build procedure. Completed 2026-11-07 after the pinned engine was
 
 ## Engine
 
-Pinned install: **Unreal Engine 5.8.4** (CL 58902052, promoted build) at
-`/run/media/system/DATA/Engines/UE_5.8.4`. The engine bundles **no** Linux clang; the system clang (23.1.4, Fedora 45) is the game-code toolchain. Game targets must use `BuildSettingsVersion.V7` to share the installed editor's build environment.
+Pinned install: **Unreal Engine 5.8.4** (CL 58902052, promoted build) at `/run/media/system/DATA/Engines/UE_5.8.4`. The engine bundles **no** Linux clang; the system clang (23.1.4, Fedora 45) is the game-code toolchain. Game targets must use `BuildSettingsVersion.V7` to share the installed editor's build environment.
 
 ## Fresh-checkout build
 
@@ -42,20 +41,14 @@ cd /run/media/system/DATA/Engines/UE_5.8.4
 Engine/Build/BatchFiles/RunUAT.sh BuildCookRun \
   -project="/run/media/system/DATA/Documents/06-games/gig-line/Game/GigLine/GigLine.uproject" \
   -noP4 -platform=Linux -clientconfig=Development \
-  -cook -allmaps -build -stage -pak \
-  -archive -archivedirectory="/run/media/system/DATA/Builds/GigLine" \
+  -cook -build -stage -pak \
+  -archive -archivedirectory="/run/media/system/DATA/Builds/GigLineQA" \
   -unattended
-# Expected: "BUILD SUCCESSFUL" (~1 min for the blank project; archive ~1.1 GiB)
-# Launch test (plain, no -map): /run/media/system/DATA/Builds/GigLine/Linux/GigLine.sh
+# Expected: "AutomationTool exiting with ExitCode=0 (Success)" and "EXIT=0", ~90 s
+# Launch test (plain, no -map): /run/media/system/DATA/Builds/GigLineQA/Linux/GigLine.sh
 ```
 
-**Launch test must open the DemoMap.** A plain `./GigLine.sh` should load
-`/Game/Hollywood/DemoMap` (set via `DefaultEngine.ini` `GameMapsSettings`). If it
-instead opens `/Engine/Maps/Templates/OpenWorld`, the game shows an empty
-non-interactive "stuck" scene — check that `GameDefaultMap` is in
-`DefaultEngine.ini`, not `DefaultGame.ini`. Confirm the loaded map in the engine
-log: `.../Linux/GigLine/Saved/Logs/GigLine.log` (`LoadMap: /Game/Hollywood/DemoMap`).
-The archive directory is deliberately **outside** the repository; never archive into the checkout.
+**Launch test must open the DemoMap.** A plain `./GigLine.sh` should load `/Game/Hollywood/DemoMap` (set via `DefaultEngine.ini` `GameMapsSettings`). If it instead opens `/Engine/Maps/Templates/OpenWorld`, the game shows an empty non-interactive "stuck" scene — check that `GameDefaultMap` is in `DefaultEngine.ini`, not `DefaultGame.ini`. Confirm the loaded map in the engine log: `.../Linux/GigLine/Saved/Logs/GigLine.log` (`LoadMap: /Game/Hollywood/DemoMap`). The archive directory is deliberately **outside** the repository; never archive into the checkout.
 
 ## Headless content checks
 
@@ -76,9 +69,7 @@ Both content-acceptance tests run headless and are the template for all asset im
 
 ## Content pipeline (current)
 
-The hero block and the demo level are built by a fixed sequence. Each step writes
-a result file under `/tmp/gigline/`; read it, because the commandlet's own stdout
-can be swallowed.
+The hero block and the demo level are built by a fixed sequence. Each step writes a result file under `/tmp/gigline/`; read it, because the commandlet's own stdout can be swallowed.
 
 | Step | Tool | Output |
 | --- | --- | --- |
@@ -86,21 +77,23 @@ can be swallowed.
 | Terrain | `Art/blender/terrain/terrain_from_dem.py` | `Art/blender/terrain/terrain-*.blend` |
 | Street | `Art/blender/street/street_mesh.py` | `Art/blender/street/street-*.blend` |
 | Site assembly | `Art/blender/site/site_assembly.py` | `Art/blender/site/site-*.blend` |
-| Site export | `Art/blender/site/export_site_fbx.py` | six FBXs, one per mesh |
-| Hero façade | `Tools/hero_facade_build.py` | `Art/blender/hero/hero-facade-*.blend` + JSON report |
+| Site export | `Art/blender/site/export_site_fbx.py` | seven FBXs, one per mesh (terrain, road, both sidewalks, both kerbs, crossing) |
+| Hero façade | `Tools/hero_facade_build.py` | `Art/blender/hero/hero-facade-*.blend` + JSON part report |
+| Block frontage | `Tools/export_block_frontage.py` | six frontage FBXs from the blockout |
+| North buildings | `Tools/export_north_buildings.py` | TCL and Tussaud's FBXs from the blockout |
 | Site import | `Tools/ue_import_site.py` | `/Game/Hollywood/Site/*` |
+| Frontage import | `Tools/ue_import_block_frontage.py` | `/Game/Hollywood/Frontage/*` |
+| North import | `Tools/ue_import_north_buildings.py` | `/Game/Hollywood/North/*` |
 | Hero import | `Tools/ue_hero_facade_import.py` | `/Game/Hollywood/ElCapitan/SM_HeroFacade` |
 | Demo map | `Tools/ue_build_demo_map.py` | `/Game/Hollywood/DemoMap` |
 | Review shots | `Tools/ue_build_review_map.py` + `Tools/render_screenshots.sh` | `Screenshots/` |
 
+Every Blender exporter calls [`Tools/fbx_export_preset.py`](../Tools/fbx_export_preset.py) (`ue_metric_v1` / `ue_character_v1`) instead of repeating the FBX argument block — one place for the scale conversion, the axis mapping and `mesh_smooth_type="FACE"` (without which every Unreal import warns about missing smoothing groups and round geometry arrives faceted).
+
 Two rules that the pipeline enforces rather than documents:
 
-- **One conversion.** Metres to Unreal centimetres happens only in
-  `Geo/tools/osm_common.py::to_unreal_local`. Sidecars (`<asset>.geo.json`) record
-  the result and `Geo/tools/asset_metadata.py audit` re-derives it.
-- **Collision is decided at import,** not later: terrain, road and sidewalks are
-  complex-as-simple; kerbs and props stay simple. A simple hull over a kerbed
-  street ramps straight across the kerb.
+- **One conversion.** Metres to Unreal centimetres happens only in `Geo/tools/osm_common.py::to_unreal_local`. Sidecars (`<asset>.geo.json`) record the result and `Geo/tools/asset_metadata.py audit` re-derives it.
+- **Collision is decided at import,** not later: terrain, road and sidewalks are complex-as-simple; kerbs and props stay simple. A simple hull over a kerbed street ramps straight across the kerb.
 
 ## Known engine quirks (2026-11-07)
 
@@ -110,20 +103,35 @@ Two rules that the pipeline enforces rather than documents:
 
 ## Packaged Linux build
 
-- 2026-11-07: blank `Game/GigLine` Development build packaged via the command above; 1.1 GiB archive at `/run/media/system/DATA/Builds/GigLine/Linux`; `GigLine.sh` launched on the desktop session, Vulkan swapchain created, 759 frames rendered across a 60 s smoke test. Controls document to be written with the first playable (`0.1.0` Gameplay section).
+Current QA archive: `/run/media/system/DATA/Builds/GigLineQA`. A plain `./GigLine.sh` opens `/Game/Hollywood/DemoMap`; controls are in [controls.md](controls.md) and shown in-game bottom-right. The packaged log is written **relative to the wrapper's working directory**, i.e. `<archive>/Linux/GigLine/Saved/Logs/GigLine.log` — not into the repository.
+
+Behaviour check without a human at the keyboard:
+
+```bash
+cd /run/media/system/DATA/Builds/GigLineQA/Linux
+./GigLine.sh -windowed -ResX=1280 -ResY=720 -nosplash -qaselftest
+# then read <archive>/Linux/GigLine/Saved/Logs/GigLine.log for "GigLine QA:" lines
+```
+
+`-qaselftest` walks for 2 s, resets, pauses/unpauses, sweeps a 16-row seam transect, fires a ground-referenced 21 m wall probe along the street, fires 40 m façade-occlusion traces sideways from the road centre wherever a building is staged, and writes a frame-time series to `Saved/Profiling/`. Every phase logs `... PASS`/`FAIL` and the run ends with `RESULT`.
+
+## Traps that cost real time in `0.1.x`
+
+| Symptom | Cause | Fix |
+| --- | --- | --- |
+| A builder reports success but the asset is unchanged | `.blend`/`.umap` are LFS-tracked and check out **read-only**; Blender and Unreal fail the save quietly | `chmod u+w <file>` first — `ue_build_*`/`ue_hero_facade_import` and every Blender builder need it |
+| `File format is not supported` when reopening a `.blend` | `hero_facade_build.py --out` writes the **FBX**; putting the `.blend` path there overwrites it with FBX bytes | `--out /tmp/…fbx --save-blend Art/…blend --report Art/…json` |
+| `Add-on not loaded: "bl_ext.blender_org.mpfb"` | `mpfb_character_export.py` needs the MPFB add-on visible to Blender | export `BLENDER_USER_SCRIPTS` (see the invocation in [../Art/blender/README.md](../Art/blender/README.md)) |
+| The packaged run exits after a couple of seconds during QA | `GigLineShotActor` runs its screenshot list and quits (`bQuitWhenDone`) | it skips its rounds when `-qaselftest` is on the command line — keep that guard |
+| Headless `-nullrhi` traces report no hits for everything | the null RHI has no physics scene | verify traces in the **packaged** run (`-qaselftest`), never in a commandlet |
+| Import logs "No smoothing group information" for every mesh | `mesh_smooth_type="OFF"` in the FBX export | use `Tools/fbx_export_preset.py` (`FACE`) |
 
 ## PIE input test (compare editor vs packaged input intake)
 
-Use to isolate whether the "no controls respond" bug is the packaged standalone's
-input intake or the Enhanced Input wiring generally.
+Use to isolate whether the "no controls respond" bug is the packaged standalone's input intake or the Enhanced Input wiring generally.
 
-- `Tools/run_pie.sh` opens the editor on `/Game/Hollywood/DemoMap`. Press the
-  green **Play** (PIE) button and walk / mouse-look.
+- `Tools/run_pie.sh` opens the editor on `/Game/Hollywood/DemoMap`. Press the green **Play** (PIE) button and walk / mouse-look.
 - Interpretation:
-  - PIE **works** -> the Enhanced Input wiring is fine and the standalone
-    packaged build's SDL input intake is the environment-dependent bug.
-  - PIE **fails** too -> the Enhanced Input setup itself is broken; rebuild
-    the input config / character from scratch.
-- The DemoMap is PIE-ready as committed: `GlobalDefaultGameMode` +
-  `GameDefaultMap=/Game/Hollywood/DemoMap`, and the map stages a PlayerStart at
-  `(-13336,-1150,600)` on the cut sidewalk with the walkable `AGigLineCharacter`.
+  - PIE **works** -> the Enhanced Input wiring is fine and the standalone packaged build's SDL input intake is the environment-dependent bug.
+  - PIE **fails** too -> the Enhanced Input setup itself is broken; rebuild the input config / character from scratch.
+- The DemoMap is PIE-ready as committed: `GlobalDefaultGameMode` + `GameDefaultMap=/Game/Hollywood/DemoMap`, and the map stages a PlayerStart at `(-13336,-1150,600)` on the cut sidewalk with the walkable `AGigLineCharacter`.

Docs/controls.md

@@ -1,7 +1,6 @@
 # Controls (`0.1.0` walkable demo)
 
-Keyboard and mouse. The same list is shown in-game, bottom-right of the frame
-(`AGigLineHUD`), and the packaged Linux build ships with these bindings.
+Keyboard and mouse. The same list is shown in-game, bottom-right of the frame (`AGigLineHUD`), and the packaged Linux build ships with these bindings.
 
 | Action | Key | Notes |
 | --- | --- | --- |
@@ -16,21 +15,16 @@ Keyboard and mouse. The same list is shown in-game, bottom-right of the frame
 
 ## Notes
 
-- Movement is relative to where you are looking (controller yaw), so the capsule
-  stays upright on the sloped street.
-- The mouse is captured on launch, so looking works without clicking first.
-  `Escape` toggles the capture as part of pause.
-- Bindings are Enhanced Input actions in `/Game/Input` built by
-  `Tools/ue_create_input_assets.py`; the mapping context is `IMC_Default`.
+- Movement is relative to where you are looking (controller yaw), so the capsule stays upright on the sloped street.
+- The mouse is captured on launch, so looking works without clicking first. `Escape` toggles the capture as part of pause.
+- Bindings are Enhanced Input actions in `/Game/Input` built by `Tools/ue_create_input_assets.py`; the mapping context is `IMC_Default`.
 
 ## Testing input without a physical keyboard
 
-`Tools/input_test.py` injects OS-level keyboard/mouse events through a virtual
-`/dev/uinput` device (see `Tools/input_emulation.py`), e.g.:
+`Tools/input_test.py` injects OS-level keyboard/mouse events through a virtual `/dev/uinput` device (see `Tools/input_emulation.py`), e.g.:
 
 ```bash
 python3 Tools/input_test.py --sequence move:2,look:3
 ```
 
-It drives the focused game window exactly like real hardware, which is how the
-controls were regression-tested on the packaged build.
+It drives the focused game window exactly like real hardware, which is how the controls were regression-tested on the packaged build.

Docs/odbl-review.md

@@ -37,22 +37,12 @@ Important nuance: ODbL governs the **database** (the OSM data as a collection an
 
 ## 4. Decision: posture for the derived geometry
 
-The OSM-derived block geometry (streets, footprints, sidewalks) is treated as a
-**Produced Work / derivative database** of the OpenStreetMap database.
+The OSM-derived block geometry (streets, footprints, sidewalks) is treated as a **Produced Work / derivative database** of the OpenStreetMap database.
 
-- The **share-alike obligation is accepted for the data layer only**. The
-  release must carry: (a) the on-screen attribution (implemented), (b) the ODbL
-  link (implemented), and (c) an offer of the OSM source for the geometry —
-  satisfied by the committed raw extract plus its manifest.
-- **Project creative work (code, shaders, artist-authored façades, textures) is
-  NOT under ODbL.** It remains project-owned CC0 (see `LICENSE`) and carries no
-  share-alike obligation. Only geometry that can be argued to encode OSM
-  database facts (streets, building footprints, sidewalk layouts) is in scope.
-- **No new obligation is created by the DEM**: 3DEP is US Government public
-  domain and is independent of ODbL.
-- **Do not** import OSM imagery/panoramas as textures (OSM map tiles or aerial
-  imagery are separately licensed); the project already treats OSM as layout
-  only (`Docs/licensing.md` rule 3).
+- The **share-alike obligation is accepted for the data layer only**. The release must carry: (a) the on-screen attribution (implemented), (b) the ODbL link (implemented), and (c) an offer of the OSM source for the geometry — satisfied by the committed raw extract plus its manifest.
+- **Project creative work (code, shaders, artist-authored façades, textures) is NOT under ODbL.** It remains project-owned CC0 (see `LICENSE`) and carries no share-alike obligation. Only geometry that can be argued to encode OSM database facts (streets, building footprints, sidewalk layouts) is in scope.
+- **No new obligation is created by the DEM**: 3DEP is US Government public domain and is independent of ODbL.
+- **Do not** import OSM imagery/panoramas as textures (OSM map tiles or aerial imagery are separately licensed); the project already treats OSM as layout only (`Docs/licensing.md` rule 3).
 
 Release checklist items this lands:
 
@@ -63,20 +53,13 @@ Release checklist items this lands:
 
 ## 5. Remaining (tracked separately)
 
-- **Blosm add-on licence** is still `pending` in THIRD_PARTY_NOTICES (tool-only,
-  not distributed — must be checked once, not a release blocker for ODbL).
-- Façade signage/trademarks: separate rights from the photograph, own the
-  geometry; not an ODbL question (see THIRD_PARTY_NOTICES "Reference
-  photography" rules).
+- **Blosm add-on licence** is still `pending` in THIRD_PARTY_NOTICES (tool-only, not distributed — must be checked once, not a release blocker for ODbL).
+- Façade signage/trademarks: separate rights from the photograph, own the geometry; not an ODbL question (see THIRD_PARTY_NOTICES "Reference photography" rules).
 
 ## 6. Sources checked
 
 - ODbL text: <https://opendatacommons.org/licenses/odbl/1-0/>
 - OSM licence summary: <https://www.openstreetmap.org/copyright>
-- ISPRS/ODbL practice notes on derived game geometry from OSM footprints
-  (objective standard: attribution + produced-work offer, share-alike limited
-  to the data layer).
+- ISPRS/ODbL practice notes on derived game geometry from OSM footprints (objective standard: attribution + produced-work offer, share-alike limited to the data layer).
 
-Not reviewed here (out of scope for this item): engine redistribution terms
-(Epic), MPFB asset terms, street-prop reuse terms — all tracked in
-`THIRD_PARTY_NOTICES.md`.
+Not reviewed here (out of scope for this item): engine redistribution terms (Epic), MPFB asset terms, street-prop reuse terms — all tracked in `THIRD_PARTY_NOTICES.md`.

Docs/release-checks.md

@@ -35,7 +35,7 @@ Measured at 1440p on the development workstation: Bazzite, Ryzen 7 7700X, 64 GB
 ## Check-record template
 
 | Version | Check | Result | Evidence | Date |
-| ------- | ----------------------- | ------ | -------- | ---- |
+| --- | --- | --- | --- | --- |
 | `0.1.0` | Traversal, both sides | PASS — Blender pre-check + in-engine swept transect, 0 holes, ground Z 317..395 | `-qaselftest`, TODO 0.1.0 notes | 2026-11-08 |
 | `0.1.0` | Placement vs references | PASS (with deliberate simplifications) | Section below, 2026-11-08 | 2026-11-08 |
 | `0.1.0` | Collision and packaging | PASS — no blocking collision, no invisible walls, no seam gaps (see audit note) | `-qaselftest` on the packaged build, 2026-11-08 | 2026-11-08 |
@@ -45,10 +45,7 @@ Measured at 1440p on the development workstation: Bazzite, Ryzen 7 7700X, 64 GB
 
 ## `0.1.0` — Placement vs references — record (2026-11-08)
 
-Checked against the reference photography (`Art/reference/`) and the Geo measurements
-(`Geo/verification/*`). Build under test: current `main` content, DemoMap rendered via
-`Tools/render_screenshots.sh` (2026-11-08, Vulkan SM5, 1920×1080); engine positions
-probed from the DemoMap (commandlet, 2026-11-08).
+Checked against the reference photography (`Art/reference/`) and the Geo measurements (`Geo/verification/*`). Build under test: current `main` content, DemoMap rendered via `Tools/render_screenshots.sh` (2026-11-08, Vulkan SM5, 1920×1080); engine positions probed from the DemoMap (commandlet, 2026-11-08).
 
 ### Placement and scale (in-engine ↔ reference)
 
@@ -80,55 +77,33 @@ probed from the DemoMap (commandlet, 2026-11-08).
 - **Crossing ramps are kerb flushes, not graded ramps** — the `0.1.1` Crossing ramp gradient item.
 - Site identity (the neoclassical hero with motto band) matches the 2009 façade photograph and the 1922 Masonic elevation within blockout fidelity.
 
-Pre-check method: `Tools/judge_screenshot.py` (vision model) flagged the simplified
-flat surfaces as "unexpected" — those flags are the deliberate deviations above, not
-placement errors. Final verdict is by human review of the shots in `Screenshots/demo/`.
+Pre-check method: `Tools/judge_screenshot.py` (vision model) flagged the simplified flat surfaces as "unexpected" — those flags are the deliberate deviations above, not placement errors. Final verdict is by human review of the shots in `Screenshots/demo/`.
 
 ## `0.1.0` — Collision and packaging — audit note (2026-11-08)
 
 Run on the packaged build (`GigLineQA`, Development, Vulkan SM5) with `-qaselftest`.
 
-- **Transect (holes/gaps):** 1456 samples over 16 rows — lane centres **plus the
-  kerb/road/sidewalk seam Ys** (−1382, −1053, +718, +1047 and neighbours) and
-  X −20000..−2000. Result **0 holes**. (The old 84-sample check covered only 3
-  lane centres; the seam rows are what this check adds.)
-- **Invisible-wall probe:** horizontal traces 30 m long, grounded at 160 cm above
-  the local ground, along the road and both seam rows. Result **0/35 blocking hits
-  inside 21 m** — no invisible walls or misplaced blockers in the street envelope.
-  (First pass used a fixed Z 160 start; the street is at Z ~366, so the probe
-  started inside the earth and reported every row as a dist-0 blocker. Grounding
-  the probe fixed that measurement bug.)
-- **Walk / reset / pause:** 761 cm in 2 s (Z steady 456), reset 0 cm, pause
-  `IsGamePaused()=1`, unpause 0 — all PASS.
-- Packaging: the packaged build launches, reaches gameplay, and the QA run quits
-  cleanly. The `GigLineShotActor` screenshot rounds are suppressed under
-  `-qaselftest` so they cannot quit the run before the audit phases.
-- Caveat recorded: ground Z extremes (−12 m / 3000 cm) are trace-start/terrain-edge
-  artifacts of the widened extent, not walkable holes — the walkable corridor is
-  continuous (walk + transect both PASS).
+- **Transect (holes/gaps):** 1456 samples over 16 rows — lane centres **plus the kerb/road/sidewalk seam Ys** (−1382, −1053, +718, +1047 and neighbours) and X −20000..−2000. Result **0 holes**. (The old 84-sample check covered only 3 lane centres; the seam rows are what this check adds.)
+- **Invisible-wall probe:** horizontal traces 30 m long, grounded at 160 cm above the local ground, along the road and both seam rows. Result **0/35 blocking hits inside 21 m** — no invisible walls or misplaced blockers in the street envelope.
+- **Facade occlusion probe:** from the road centre, 40 m traces sideways at walking height toward each frontage, required only where the map stages a building (the spans are listed in `AGigLineCharacter` and mirror `Tools/ue_build_demo_map.py`). Result **0/9 directions without a blocking wall** — the player cannot walk through the hero or the frontage. This probe found the hero façade had **no simple collision** at all (complex-only, so traces and capsule sweeps passed through it); it is now `UseComplexAsSimple`. Auto-generated convex hulls were tried first and rejected: on a 95-part, 26 m façade they bulged into the street (the wall probe went 0/35 → 2/35). (First pass used a fixed Z 160 start; the street is at Z ~366, so the probe started inside the earth and reported every row as a dist-0 blocker. Grounding the probe fixed that measurement bug.)
+- **Walk / reset / pause:** 761 cm in 2 s (Z steady 456), reset 0 cm, pause `IsGamePaused()=1`, unpause 0 — all PASS.
+- Packaging: the packaged build launches, reaches gameplay, and the QA run quits cleanly. The `GigLineShotActor` screenshot rounds are suppressed under `-qaselftest` so they cannot quit the run before the audit phases.
+- Caveat recorded: ground Z extremes (−12 m / 3000 cm) are trace-start/terrain-edge artifacts of the widened extent, not walkable holes — the walkable corridor is continuous (walk + transect both PASS).
 
 ## `0.1.0` — 60 FPS at 1440p — record (2026-11-08)
 
-**Build under test:** packaged `GigLineQA` Development, UE **5.8.4**, Vulkan SM5,
-NVIDIA 615.78.08 (RTX 5070 Ti), Bazzite, Ryzen 7 7700X, 64 GB RAM.
+**Build under test:** packaged `GigLineQA` Development, UE **5.8.4**, Vulkan SM5, NVIDIA 615.78.08 (RTX 5070 Ti), Bazzite, Ryzen 7 7700X, 64 GB RAM.
 
-**Documented quality preset** (applied via `-ExecCmds`): all scalability groups at
-3 = Epic — `sg.ViewDistanceQuality 3, sg.ShadowQuality 3,
-sg.GlobalIlluminationQuality 3, sg.ReflectionQuality 3, sg.PostProcessQuality 3,
-sg.TextureQuality 3, sg.EffectsQuality 3, sg.FoliageQuality 3, sg.ShadingQuality 3`.
+**Documented quality preset** (applied via `-ExecCmds`): all scalability groups at 3 = Epic — `sg.ViewDistanceQuality 3, sg.ShadowQuality 3, sg.GlobalIlluminationQuality 3, sg.ReflectionQuality 3, sg.PostProcessQuality 3, sg.TextureQuality 3, sg.EffectsQuality 3, sg.FoliageQuality 3, sg.ShadingQuality 3`.
 
-**Upscaling state (recorded from the run):** `r.AntiAliasingMethod=4` → **TSR on**,
-default screen percentage, `r.VSync=0` (**off**), frame generation **off/unavailable**
-(`r.Streamline.FrameGeneration.Mode` absent → -999).
+**Upscaling state (recorded from the run):** `r.AntiAliasingMethod=4` → **TSR on**, default screen percentage, `r.VSync=0` (**off**), frame generation **off/unavailable** (`r.Streamline.FrameGeneration.Mode` absent → -999).
 
-**Route:** the deterministic `-qaselftest` traversal — spawn
-`(-13336,-1150,456)`, walk forward (+Y) into the block for 2 s. Frame times are
-captured every frame over that route (829 frames), not a single sample.
+**Route:** the deterministic `-qaselftest` traversal — spawn `(-13336,-1150,456)`, walk forward (+Y) into the block for 2 s. Frame times are captured every frame over that route (829 frames), not a single sample.
 
 **Result at 2560×1440:**
 
 | Metric          | Value                 |
-| --- | --- |
+| --------------- | --------------------- |
 | Frames captured | 829                   |
 | Average         | **2.42 ms → 414 fps** |
 | p50             | 2.38 ms               |
@@ -136,13 +111,9 @@ captured every frame over that route (829 frames), not a single sample.
 | p99             | 3.01 ms (≈332 fps)    |
 | Max             | 4.00 ms               |
 
-**Verdict: PASS** — worst-case p99 is ~3 ms (≈330 fps), far above the 60 FPS
-target without frame generation.
+**Verdict: PASS** — worst-case p99 is ~3 ms (≈330 fps), far above the 60 FPS target without frame generation.
 
-**Variance note:** two back-to-back runs measured ~9.2 ms (≈108 fps) when another
-game instance / busy compositor overlapped the capture; repeated clean runs
-(windowed and fullscreen, Wayland and X11 drivers, window focused) all measured
-~2.4–2.5 ms. The high outlier is recorded here rather than hidden.
+**Variance note:** two back-to-back runs measured ~9.2 ms (≈108 fps) when another game instance / busy compositor overlapped the capture; repeated clean runs (windowed and fullscreen, Wayland and X11 drivers, window focused) all measured ~2.4–2.5 ms. The high outlier is recorded here rather than hidden.
 
 **Reproduce:**
 
@@ -156,8 +127,7 @@ Committed frame-time series: `Docs/perf/0.1.0-walk-frametimes.csv`.
 
 ## `0.1.0` — Fresh checkout build — record (2026-11-08)
 
-Followed the documented steps in [`Docs/build.md`](build.md) exactly, into a clean
-directory with no prior state:
+Followed the documented steps in [`Docs/build.md`](build.md) exactly, into a clean directory with no prior state:
 
 ```bash
 git clone https://git.allucanget.biz/zwitschi/gig-line.git /tmp/fresh-check
@@ -170,35 +140,23 @@ Engine/Build/BatchFiles/Linux/Build.sh GigLine Linux Development \
   -project=/tmp/fresh-check/Game/GigLine/GigLine.uproject -WaitMutex
 ```
 
-- Clone of `main` at `4bc41e9`; LFS objects fetched (`DemoMap.umap` is real UE
-  package content, not a pointer).
-- `GigLineEditor` → **Result: Succeeded** (28.2 s); produced
-  `/tmp/fresh-check/Game/GigLine/Binaries/Linux/libUnrealEditor-GigLine.so`.
+- Clone of `main` at `4bc41e9`; LFS objects fetched (`DemoMap.umap` is real UE package content, not a pointer).
+- `GigLineEditor` → **Result: Succeeded** (28.2 s); produced `/tmp/fresh-check/Game/GigLine/Binaries/Linux/libUnrealEditor-GigLine.so`.
 - `GigLine` (game) → **Result: Succeeded** (26.9 s).
-- Engine: documented external install at `/run/media/system/DATA/Engines/UE_5.8.4`
-  (UE 5.8.4), system clang; no machine-specific paths beyond the documented
-  `-project=` argument.
+- Engine: documented external install at `/run/media/system/DATA/Engines/UE_5.8.4` (UE 5.8.4), system clang; no machine-specific paths beyond the documented `-project=` argument.
 
 **Verdict: PASS.**
 
 ## `0.1.0` — Packaged Linux build + documented controls — record (2026-11-08)
 
-**Package:** `RunUAT BuildCookRun … -platform=Linux -clientconfig=Development
--cook -build -stage -pak -archive -archivedirectory=/run/media/system/DATA/Builds/GigLineQA`
-→ `EXIT=0` (Success).
+**Package:** `RunUAT BuildCookRun … -platform=Linux -clientconfig=Development -cook -build -stage -pak -archive -archivedirectory=/run/media/system/DATA/Builds/GigLineQA` → `EXIT=0` (Success).
 
-**Launch:** `./GigLine.sh -windowed` (plain, no map argument) →
-`LogLoad: LoadMap: /Game/Hollywood/DemoMap?Name=Player` — the packaged game opens
-the walkable demo directly (the default-map fix holds in a package, not just the
-editor). No `LogLinker`/missing-asset/failed-to-find errors in the run.
+**Launch:** `./GigLine.sh -windowed` (plain, no map argument) → `LogLoad: LoadMap: /Game/Hollywood/DemoMap?Name=Player` — the packaged game opens the walkable demo directly (the default-map fix holds in a package, not just the editor). No `LogLinker`/missing-asset/failed-to-find errors in the run.
 
 **Controls documented and shown in-game:**
-- `Docs/controls.md` — full binding table (WASD, mouse look, Space, R, Esc) plus
-  how to test input headlessly.
-- `AGigLineHUD` now draws a control legend bottom-right every frame:
-  "WASD move · Mouse look · Space jump · R reset · Esc pause".
-- Verified in the packaged capture: the bottom-right text bbox is 426×12 px
-  (a single right-aligned line), attributed text bottom-left. Screenshot:
-  `Docs/perf/0.1.0-packaged-hud-controls.png`.
+
+- `Docs/controls.md` — full binding table (WASD, mouse look, Space, R, Esc) plus how to test input headlessly.
+- `AGigLineHUD` now draws a control legend bottom-right every frame: "WASD move · Mouse look · Space jump · R reset · Esc pause".
+- Verified in the packaged capture: the bottom-right text bbox is 426×12 px (a single right-aligned line), attributed text bottom-left. Screenshot: `Docs/perf/0.1.0-packaged-hud-controls.png`.
 
 **Verdict: PASS.**

Docs/setup.md

@@ -83,13 +83,24 @@ Without `git lfs install`, adding an LFS-matched file does not error — it comm
 
 Sizes: the engine lives outside the repository (pinned install path recorded in `toolchain.md`). The repository holds the Unreal project, Blender sources, geo sources, and tooling.
 
-**Fresh checkout not yet tested end to end.** The build procedure in [build.md](build.md) was produced from a working tree, not from a clean clone. Exercise it before `v0.1.0` is tagged — it is a release check on the board.
+**Fresh checkout verified 2026-11-08.** A clean clone of `main` with `git lfs pull` built both `GigLineEditor` and `GigLine` against the documented external engine (recorded in [release-checks.md](release-checks.md)). Re-run it before a release tag if the engine pin or the module's dependencies change.
+
+### Optional keys (local only)
+
+Two tools talk to paid services and read their keys from the gitignored `.env`:
+
+| Variable | Used by | Needed for |
+| --- | --- | --- |
+| `OPENROUTER_API_KEY` | `Tools/judge_screenshot.py`, `Tools/facade_detail_concepts.py` | vision pre-check and AI concept plates |
+| `MAPBOX_ACCESS_TOKEN` | `Geo/tools/mapbox_buildings.py` | the second building-height source |
+
+Nothing in the build, the tests or the release path needs either key. Never commit `.env`; `git check-ignore .env` should succeed.
 
 ## Known blockers
 
 | Blocker | Owner | Needed for |
 | --- | --- | --- |
 | Delete the fallback 5.2.0 engine archive (`/run/media/system/DATA/Downloads/Linux_Unreal_Engine_5.2.0.zip`) once the 5.8.4 pin is trusted through asset production | agent | Disk hygiene (19.6 GiB), pin safety |
-| Fresh-checkout build exercised against the documented procedure | agent | `v0.1.0` release check |
+| ~~Fresh-checkout build exercised against the documented procedure~~ | — | Done 2026-11-08 |
 
 Closed 2026-11-07: Epic account and engine download, QGIS `lts` removal, Blosm and MPFB on Blender 5.2 (headless invocation fix in `Art/blender/README.md`), engine validation on Bazzite, full project bootstrap. Earlier closed: Bazzite update and reboot, driver and Vulkan verification, `git-lfs`/`clang`/`cmake`/`ninja` layering.

Game/GigLine/Source/GigLine/GigLineCharacter.cpp

@@ -416,6 +416,81 @@ void AGigLineCharacter::StartQASelfTest()
 					TEXT("GigLine QA: wall probe %d/%d traces with blocking hit inside 21 m -> %s"),
 					Walls, WallSamples,
 					Walls == 0 ? TEXT("PASS") : TEXT("FAIL"));
+
+				// Facade occlusion probe: walkable street is only half the story —
+				// the player must also NOT be able to walk through the buildings.
+				// From the road centre, fire 40 m sideways at walking height toward
+				// each frontage and require a blocking hit. A miss means the
+				// building has no collision (or only non-blocking collision) and the
+				// player would pass through the wall.
+				// Expect a wall only where the map actually stages a building.
+				// Spans below mirror the actors placed by Tools/ue_build_demo_map.py
+				// (frontage + hero) and the two north buildings; update them if
+				// that list changes. Gaps between buildings are legitimate misses.
+				struct FSpan { float Min, Max; };
+				static const FSpan SouthSpans[] = {
+					{-24276.f, -17700.f}, // 6922
+					{-17749.f, -14591.f}, // 6902
+					{-14638.f, -12034.f}, // 6840 hero
+					{-12082.f, -8210.f},  // 6838 El Capitan Theatre
+					{-7854.f, -7252.f},   // 6822 Budget
+					{-6608.f, -3307.f},   // 6806-6820
+					{-3320.f, -1437.f},   // 6800 Lee Drug
+				};
+				static const FSpan NorthSpans[] = {
+					{-27071.f, -22799.f}, // Madame Tussaud's
+					{-22889.f, -18442.f}, // TCL Chinese Theatre
+				};
+				auto InSpans = [](const FSpan* Spans, int32 Count, float X)
+				{
+					for (int32 i = 0; i < Count; ++i)
+					{
+						if (X >= Spans[i].Min && X <= Spans[i].Max) { return true; }
+					}
+					return false;
+				};
+				int32 Facades = 0, FacadeSamples = 0;
+				for (float X0 = -19000.0f; X0 <= -3000.0f; X0 += 2000.0f)
+				{
+					for (float Dir : {1.0f, -1.0f}) // +Y south frontage, -Y north side
+					{
+						const bool bExpectWall = (Dir > 0.0f)
+							? InSpans(SouthSpans, UE_ARRAY_COUNT(SouthSpans), X0)
+							: InSpans(NorthSpans, UE_ARRAY_COUNT(NorthSpans), X0);
+						if (!bExpectWall)
+						{
+							continue;
+						}
+						FHitResult GroundHit2;
+						FCollisionQueryParams GQ2(TEXT("GigLineFacadeGround"), false, this);
+						if (!W->LineTraceSingleByChannel(GroundHit2,
+							FVector(X0, 0.0f, 3000.f), FVector(X0, 0.0f, -1000.f),
+							ECC_Visibility, GQ2))
+						{
+							continue;
+						}
+						const float ProbeZ2 = GroundHit2.ImpactPoint.Z + 160.f;
+						FHitResult Hit2;
+						FCollisionQueryParams Q2(TEXT("GigLineFacadeProbe"), false, this);
+						const bool bHit2 = W->LineTraceSingleByChannel(Hit2,
+							FVector(X0, 0.0f, ProbeZ2),
+							FVector(X0, Dir * 4000.f, ProbeZ2),
+							ECC_Visibility, Q2);
+						++FacadeSamples;
+						const bool bBlocking = bHit2 && Hit2.GetActor() != nullptr;
+						if (!bBlocking)
+						{
+							++Facades;
+							UE_LOG(LogTemp, Log,
+								TEXT("GigLine QA: facade probe miss at X %.0f dir %.0f (no blocking hit in 40 m)"),
+								X0, Dir);
+						}
+					}
+				}
+				UE_LOG(LogTemp, Log,
+					TEXT("GigLine QA: facade probe %d/%d directions without a blocking wall -> %s"),
+					Facades, FacadeSamples,
+					Facades == 0 ? TEXT("PASS") : TEXT("FAIL"));
 			}
 
 			// 7.0: verdict, then stop ticking.

MEMORY.md

@@ -418,3 +418,110 @@ Scope: facts and traps that cost time to establish. Planned work lives in [TODO.
 - Rebuilt hero → re-imported (`SM_HeroFacade`, bounds 2604 × 1257 × 1450 cm) →
   DemoMap rebuilt → screenshots re-rendered. Note `ue_hero_facade_import.py` saves
   the map, so `chmod u+w` the `.umap` first or the import silently does not persist.
+
+## 2026-11-09 — AI detail plates from reference photos; floating windows fixed
+
+- `Tools/facade_detail_concepts.py` generates architectural detail plates from one
+  local reference photograph via OpenRouter image models (default
+  `google/gemini-2.5-flash-image`; the sibling project uses the same route in
+  `tools/generate_textures.py` — chat/completions with a text + image_url content
+  part, image returned as `message.images[].image_url.url`). Eight studies,
+  `--list` free, `--all` generates, `-vN` never overwrites, `.refgen.json` sidecar
+  per image, all output under gitignored `Art/reference/facade-details/`.
+- **Prompt gotcha:** the model refuses when the prompt describes features the
+  reference photograph does not show ("the image you sent appears to be a
+  decorative architectural detail, not an entrance with steps"). Prompts must
+  describe the *reference subject* and only restage light/people/surface.
+- **Output is real:** 1184×864 to 1344×768 PNGs, ~2 MB each.
+- **Measured defect found and fixed:** hero window panes sat at Y −1.98 while the
+  mass front is Y −0.50 and the columns reach −1.02 — i.e. glazing floating 1.44 m
+  in front of the wall and ahead of the colonnade. Now `WINDOW_Y = −0.56`
+  (6 cm proud of the wall, behind the columns). Visible as dark openings in
+  `review-hero-facade-front`.
+- Reminder: `.blend` is LFS read-only on checkout — `chmod u+w` or Blender fails
+  with "Cannot save blend file … not writable" (this bit again here).
+
+## 2026-11-09 — UE export hygiene: smoothing groups + facade collision
+
+- **All our FBX exporters used `mesh_smooth_type="OFF"`**, which is why every Unreal
+  import logged "No smoothing group information was found for this mesh". The hero
+  now exports `"FACE"` and its round parts are shaded with
+  `shade_smooth_by_angle(35°)` before export: cylinders read as round instead of
+  faceted, and the import warning is gone (6 → 0).
+- **The hero façade had no simple collision** (complex-only), so line traces and
+  capsule sweeps passed straight through it — the player could walk through the
+  wall of the demo. Caught by a new `-qaselftest` **facade occlusion probe** (40 m
+  sideways traces from the road centre at walking height).
+- **Auto-generated convex collision on a 95-part 26 m façade is unusable**: it
+  produced coarse hulls that bulged into the street and the wall probe went
+  0/35 → 2/35. Rejected in favour of `UseComplexAsSimple` via
+  `UGigLineAssetTools.set_complex_collision_as_simple` (same reason the terrain
+  uses it), saved on the asset.
+- Probe expectations must mirror the staged buildings: the facade probe now carries
+  explicit X spans per frontage (and the TCL/Tussaud's spans on the north side) so
+  a gap between buildings is not reported as a defect.
+
+## 2026-11-09 — one FBX export preset instead of six copies
+
+- The `bpy.ops.export_scene.fbx(...)` argument block was duplicated in six scripts
+  (hero, block frontage, north buildings, site, scale test, MPFB character), and
+  all six carried `mesh_smooth_type="OFF"` — hence the "No smoothing group
+  information was found" warning on every import.
+- Now `Tools/fbx_export_preset.py` holds `ue_metric_v1` and `ue_character_v1`:
+  `preset_kwargs()` (bpy-free, unit-tested) plus `export_static()` /
+  `export_character()` wrappers that import `bpy` lazily. Every caller imports it
+  and passes `selection=True/False`; the seven duplicated blocks are gone.
+- Callers in `Tools/` resolve the module with
+  `sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))`; the Blender-side
+  `Art/blender/site/export_site_fbx.py` computes the repo root
+  (`..`, `..`, `..`) and joins `Tools`. Getting that wrong silently inserts
+  `Tools/Tools` — check the import path when adding a caller.
+- Verified end to end: scale test, hero, frontage (6/6), site (7/7) and north
+  buildings all re-exported through the preset, re-imported with **0 smoothing
+  warnings**, DemoMap rebuilt and `-qaselftest` all PASS (walk, transect 0 holes,
+  wall probe 0/35, facade probe 0/9).
+- `mpfb_character_export.py` was not re-run: it needs the MPFB add-on on
+  `BLENDER_USER_SCRIPTS` ("Add-on not loaded: bl_ext.blender_org.mpfb"), which is
+  pre-existing and unrelated; the character is not in `0.1.x` gameplay.
+
+## 2026-11-09 — v0.1.2 released
+
+- Cornice finished: projecting corona over a **52-dentil course** (0.18 × 0.30 ×
+  0.22 m at 0.45 m centres, z 12.12–12.34, 0.25 m clear of the corona). Hero is now
+  3 044 tris across 148 parts, still 14.50 m. Verified: packaged `-qaselftest` all
+  PASS (transect 0 holes, wall probe 0/35, facade probe 0/9).
+- `CHANGELOG.md` gets the `0.1.2` entry (added/changed/fixed/verified/limitations),
+  the `0.1.2` section is removed from `TODO.md`, `ROADMAP.md` status updated, tag
+  `v0.1.2` cut after the merge.
+- Assumptions recorded rather than hidden: dentil spacing, base and abacus
+  dimensions are not resolvable in our reference photography.
+
+## 2026-11-09 — elevation cameras levelled (straight verticals)
+
+- archviz MUST: an elevation must not lean. `hero-facade-front` looked up ~4° from
+  4.2 m at a 7.6 m target; `demo-spawn-view` and `demo-street-level` were pitched
+  too. All three now put the camera at the target's height, so
+  `FindLookAtRotation` yields pitch 0 and roll 0 and verticals are parallel by
+  construction.
+- Do not try to *measure* verticality from the rendered PNG with a naive edge
+  scan: banners, windows and the parapet produce different edge sets at different
+  heights and the pairwise match is meaningless (it reported a 418 px "drift").
+  Verify it geometrically in the camera list instead.
+
+## 2026-11-09 — 0.1.3 packaging/setup fixes
+
+- **`Tools/ue_common.py`**: `make_writable()` clears the read-only bit an LFS
+  `.umap` checks out with (otherwise `save_map()` returns False with no error and
+  the staged actors vanish), and `require_saved()` makes that failure visible.
+  `ue_hero_facade_import.py` and `ue_import_north_buildings.py` never did this —
+  which is why importing the hero appeared to succeed while saving nothing.
+  Verified by forcing `chmod u-w` on DemoMap first: the run logged
+  `map writable: chmod u+w … (was 0o444)`, then `save_map: True`, exit 0.
+- Gotcha while adding it: `ue_hero_facade_import.py` had **no** `import os`/`sys`
+  (only `unreal`), so the sys.path line raised `NameError: name 'sys' is not
+  defined` inside the commandlet — an exit code of 255 with no obvious cause.
+- Docs: `build.md` gained the current pipeline table (7 site FBXs, frontage, north,
+  hero, map), the `Builds/GigLineQA` archive, the packaged-log path, `-qaselftest`
+  usage and a **traps** table; `setup.md` marks the fresh-checkout build verified and
+  documents the two optional API keys; architecture 07 + combined doc corrected the
+  build-output path.

Screenshots/README.md

@@ -58,5 +58,6 @@ Rebuilds `Game/GigLine/Content/Test/ReviewMap.umap` from current content, runs t
 
 - Floor speckle from the `Constant3Vector` wiring in `Tools/ue_build_review_map.py`.
 - Hero façade renders pale — Blender flat colours with no normal/roughness, so it reads as untextured stone (the `0.1.4` façade patch, not a lighting bug).
-- Banners and window panels float detached from the colonnade wall (next modelling pass).
+- Banners sit on the column line rather than the wall (acceptable: they hang on the columns in the photographs).
+- ~~Banners and window panels float detached from the colonnade wall~~ — **window panes fixed 2026-11-09**: they sat at Y −1.98, 1.44 m in _front_ of the wall and ahead of the column line; they now sit on the wall plane at Y −0.56, behind the columns, and read as dark openings (see `review-hero-facade-front`).
 - Between kerb and building line, the walkable surface is the terrain mesh, not a modelled pavement.

TODO.md

@@ -9,28 +9,6 @@ Actionable task list for this project. This file is the single, central place fo
 - When all steps in a version section are done: write a `CHANGELOG.md` entry, then remove the version section from this file.
 - Release gate: a version is tagged only on the owner's explicit go-ahead once its release checks pass, not automatically when the checkboxes close.
 
-## 0.1.2 — Scale and façade corrections (patch)
-
-Suggested blender skills: **references** (reference-image-match and visual-match-checklist templates — measure the guessed heights and colonnade proportions against the photographs), **archviz** (real-world scale and façade composition discipline), **camera-cinematography** (reproduce the reference camera angles when comparing renders to photos).
-
-### Patch tasks - active - 01a1b26b-3c94-707f-9665-2f6b4a79b564 (branch `scale-facade-0.1.2`)
-
-- [x] Correct building scale and street proportions flagged against references. **Mapbox adopted 2026-11-09.** `Geo/tools/mapbox_buildings.py` merges our OSM heights with Mapbox's building data for the same footprints; after adopting its two findings the cross-check reports **66 match, 6 non-building, 0 disagreements**. Adopted: **`LEVEL_HEIGHT` 3.2 → 3.1 m** (`block_height_report.py`, and the Blosm `--level-height` default), plus explicit `HEIGHT_OVERRIDES` (3.0 m) for the three rear `building=yes`/`apartments` structures Mapbox gives as single-storey. Blockout regenerated, frontage re-exported/re-imported, DemoMap rebuilt; packaged `-qaselftest` all PASS. Measured effect: 6922 42.1 → 39.1 m, El Capitan Theatre 20.0 → 20.5 m (both now ~1.9 m above their table height = roof mass).
-- [ ] Refine hero façade details where reference photography shows discrepancies.
-- [x] **Replace the placeholder heights.** **Resolved 2026-11-08 — they were never unknown buildings.** The three "guessed" ways are not building volumes at all: `1360755125` and `1360755126` are `building=roof` at `layer=1` (elevated canopies) and `1417995292` is `amenity=shelter` / `shelter_type=public_transport` (a transit shelter). The report defaulted them to "2 levels × 3.2 m" and produced the bogus 6.4 m. `Geo/tools/block_height_report.py` now classifies roof/shelter explicitly and reports **0 guessed heights**: all 15 block volumes have a real `height` tag, a `building:levels` derivation, or are correctly excluded as non-building volumes. No photograph measurement was needed, and no frontage building was affected.
-- [x] Resolve the remaining unknown on the hero: the colonnade currently occupies about 45 % of the height against roughly 50–60 % in the photographs. Fix the vertical proportions. **Fixed 2026-11-09.** Measured baseline: colonnade (columns + capitals) 6.90 m of the 14.50 m envelope = **47.6 %**, because the entablature (3.40 m) and parapet (2.20 m) left only 7.90 m for the order. Thinned both to **3.00 m** and **1.80 m** (`Tools/hero_facade_build.py`), which lifts the colonnade to **7.70 m = 53.1 %** — inside the photographed 50–60 % band, with the 14.50 m envelope, the motto band and the medallions unchanged in position relative to the parapet. Hero rebuilt, re-imported (bounds 2604 × 1257 × 1450 cm) and re-rendered.
-- [ ] Tag `v0.1.2` and write `CHANGELOG.md` entry; then remove this section.
-
-## 0.1.3 — Packaging and setup fixes (patch)
-
-Suggested blender skills: **export-pipeline** and **unreal-export** (scale/pivot/normals/materials/collision verification) if any packaging defect traces back to the Blender export presets.
-
-### Patch tasks
-
-- [ ] Fix any packaging or build issues encountered in `0.1.x`.
-- [ ] Update `Docs/` setup instructions for anything that changed.
-- [ ] Tag `v0.1.3` and write `CHANGELOG.md` entry; then remove this section.
-
 ## 0.1.4 — Proper building façades (patch)
 
 Suggested blender skills: **procedural-modeling** + **geometry-nodes** (the façade module kit — bay, pilaster, cornice, parapet, window, shopfront, door — as reusable node groups), **archviz** (real-world scale and façade composition), **materials** (procedural brick, concrete, stone, render, glass — the ported generators), **texture-workflow** (AO/curvature/normal bakes and decals for the motto band and medallions), **uv-workflow** (texel density and modular UV layouts for the kit), **scene-assembly** (assembling kit pieces onto the fifteen block buildings), **lookdev** (screenshot-comparison loop until shading reads correctly), **historical-worlds** or **realistic-style** (1920s Hollywood Blvd neoclassical direction), **asset-optimization** + **unreal-export** (pre-export validation, `ue_metric_v1` preset), **qa-review** (final gate before the `Tools/render_screenshots.sh` review).

Tools/README.md

@@ -16,6 +16,8 @@ Geographic tools live in [`Geo/tools/`](../Geo/README.md) and the Blender-side b
 | Tool | Purpose |
 | --- | --- |
 | `check-lfs.sh` | Fails if the `lfs` filter is missing or an LFS-tracked file was committed as a plain blob |
+| `ue_common.py` | Shared helpers for the Unreal commandlet scripts: `make_writable()` clears the read-only bit an LFS `.umap` checks out with (otherwise `save_map()` returns False silently), and `require_saved()` makes that failure explicit. |
+| `fbx_export_preset.py` | The **single** FBX export preset (`ue_metric_v1` / `ue_character_v1`): metres→centimetres via `FBX_SCALE_NONE`, axis mapping east +X / north −Y / up +Z, `mesh_smooth_type="FACE"` (smoothing groups survive the import). Every Blender exporter imports it instead of copying the argument block; `preset_kwargs()` is bpy-free and unit-tested. |
 | `sibling_asset_audit.py` | Reads the sibling project's prop library from GLB headers into `Art/props/reuse-manifest.json`; copies nothing |
 | `scale_test_export.py` / `ue_scale_test_import.py` | The 1 m = 100 uu scale test; the named presets `ue_metric_v1` live in these two files |
 
@@ -57,9 +59,16 @@ Geographic tools live in [`Geo/tools/`](../Geo/README.md) and the Blender-side b
 | Command | Purpose |
 | --- | --- |
 | `UnrealEditor <uproject> /Game/Hollywood/DemoMap -game -qaselftest` | Headless behaviour check: drives forward input for 2 s, then resets and pauses. Logs `GigLine QA: ... PASS/FAIL` lines and a final `RESULT`. Runs only with `-qaselftest`, so normal play is unaffected. |
-| `-qaselftest` phases | Walk, reset, pause/unpause, a 16-row seam transect (0 holes) and a ground-referenced wall probe (0/35), plus a frame-time capture writing `Saved/Profiling/perf-walk-frametimes.csv` and logging `GigLine PERF:`. |
+| `-qaselftest` phases | Walk, reset, pause/unpause, a 16-row seam transect (0 holes), a ground-referenced wall probe (0/35) and a **facade occlusion probe** that fires sideways from the road centre and requires a blocking wall wherever a building is staged (0/9), plus a frame-time capture writing `Saved/Profiling/perf-walk-frametimes.csv` and logging `GigLine PERF:`. |
 | `gigline.SetupLogs` cvar | Spawn/input setup logging, **off by default** (`DefaultEngine.ini [ConsoleVariables]`); enable at runtime with `gigline.SetupLogs 1`. |
 
+## Reference and concept generation
+
+| Tool | Purpose |
+| --- | --- |
+| `facade_detail_concepts.py` | Generates **frontal building plates** (whole elevation, entrance in its facade, or building with neighbours) from a local reference photograph with an image model (OpenRouter); close-up detail crops are deliberately not requested because they cannot be measured for proportion. `--list` is free and shows which studies have their reference present; `--all`/`--only <name>` generates. Never overwrites (writes `-v2`, `-v3`), writes a `.refgen.json` sidecar per image (model, prompt, source photo, SHA-256), and puts everything under `Art/reference/facade-details/` — gitignored, local-only, never shipped. Costs money per image, so it is never automatic. |
+| `judge_screenshot.py` | (see Visual review) |
+
 ## Input injection
 
 | Tool | Purpose |

Tools/export_block_frontage.py

@@ -19,6 +19,9 @@ import os
 import sys
 
 import bpy
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 
 # blockout object name -> (asset name, note). Addresses from the verification doc.
 BUILDINGS = {
@@ -69,20 +72,7 @@ def main():
         bpy.context.view_layer.objects.active = new_obj
 
         path = os.path.join(args.out, asset_name + ".fbx")
-        bpy.ops.export_scene.fbx(
-            filepath=path,
-            use_selection=True,
-            object_types={"MESH"},
-            apply_unit_scale=True,
-            apply_scale_options="FBX_SCALE_NONE",
-            axis_forward="-Y",
-            axis_up="Z",
-            use_space_transform=True,
-            use_mesh_modifiers=True,
-            mesh_smooth_type="OFF",
-            path_mode="AUTO",
-            bake_space_transform=False,
-        )
+        fbx_preset.export_static(path, selection=True)
         world = new_obj.matrix_world
         zs = [(world @ v.co).z for v in new_mesh.vertices]
         ys = [(world @ v.co).y for v in new_mesh.vertices]

Tools/export_north_buildings.py

@@ -13,6 +13,9 @@ import os
 import sys
 
 import bpy
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 
 BUILDINGS = ("TCL Chinese Theatre", "Madame Tussaud's")
 
@@ -50,20 +53,7 @@ def main():
         bpy.context.view_layer.objects.active = new_obj
 
         path = os.path.join(args.out, name.replace(" ", "_").replace("'", "") + ".fbx")
-        bpy.ops.export_scene.fbx(
-            filepath=path,
-            use_selection=True,
-            object_types={"MESH"},
-            apply_unit_scale=True,
-            apply_scale_options="FBX_SCALE_NONE",
-            axis_forward="-Y",
-            axis_up="Z",
-            use_space_transform=True,
-            use_mesh_modifiers=True,
-            mesh_smooth_type="OFF",
-            path_mode="AUTO",
-            bake_space_transform=False,
-        )
+        fbx_preset.export_static(path, selection=True)
         world = new_obj.matrix_world
         zs = [(world @ v.co).z for v in new_mesh.vertices]
         print(f"[north] {name:22} verts {len(new_mesh.vertices):5}  z {min(zs):+.2f}..{max(zs):+.2f} m "

Tools/facade_detail_concepts.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Generate frontal building plates from the local reference photography.
+
+Each study takes one photograph we already hold (`Art/reference/`, gitignored) as
+the geometric anchor and asks an image model to re-stage it as a clean **frontal
+view of the building** — the whole elevation, the entrance in its facade, or the
+building with its neighbours — evenly lit, no crowd, no staging, so the modelling
+pass has something measurable instead of a tourist photo.
+
+Deliberately **not** close-up detail crops: a doorway or cornice crop cannot be
+measured for proportion, which is what the modelling pass actually needs.
+
+    python3 Tools/facade_detail_concepts.py --list
+    python3 Tools/facade_detail_concepts.py --only door-recess,parapet-motto
+    python3 Tools/facade_detail_concepts.py --all
+    python3 Tools/facade_detail_concepts.py --all --model google/gemini-2.5-flash-image
+
+Output: `Art/reference/facade-details/<study>.png` plus a `<study>.refgen.json`
+sidecar recording the model, the source photograph, the prompt and the SHA-256 of
+the result. `Art/reference/` is gitignored, so **neither the images nor the
+sidecars are committed** — they are local working material. The study list and
+the tool are the committed part.
+
+Design notes
+------------
+* Standard library only: the OpenRouter chat-completions call is `urllib`, and
+  the returned `data:` URL is decoded with `base64` and written straight to disk.
+* An existing output is never overwritten; `-v2`, `-v3` … are used instead, so
+  re-running after a prompt edit keeps both studies comparable.
+* Generation costs money, so it is never automatic: `--list` is free, and every
+  generating run prints the model and the study count first.
+* The token is read from `OPENROUTER_API_KEY` or the ignored `.env` and is never
+  written to a sidecar or a log line.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+REFERENCE_DIR = os.path.join(ROOT, "Art", "reference")
+OUT_DIR = os.path.join(REFERENCE_DIR, "facade-details")
+API_URL = "https://openrouter.ai/api/v1/chat/completions"
+DEFAULT_MODEL = "google/gemini-2.5-flash-image"
+
+# The instruction appended to every study. Kept identical to the sibling
+# project's convention so the two sets stay comparable: the photograph fixes the
+# geometry, the prompt only restages light, weather, people and surface.
+ANCHOR_SUFFIX = (
+    "Use the attached reference photograph as the source of the architecture: keep "
+    "the building's proportions, storey count, column rhythm, band heights and "
+    "signage placement exactly as photographed. You may REFRAME — step back across "
+    "the street, zoom out or widen the field of view — so that the whole building "
+    "fits in the frame from the pavement to the parapet; the reference is often "
+    "cropped and the plate must not be. Keep the view exterior and frontal (or "
+    "three-quarter where asked). Restage only lighting, weather, people and surface "
+    "condition. Do not invent extra storeys, wings or ornaments, and do not change "
+    "the architecture to fit the frame."
+)
+
+# name -> (reference photo relative to Art/reference/, what the plate must show)
+#
+# Verified framing (vision pre-check, 2026-11-09): the model follows the reference
+# crop closely, so a plate is only as wide as its source photo. `building-entrance`
+# and `building-street-front` come back as full-elevation frontal views; the studies
+# anchored on the tightly cropped 2009 facade photo stay cropped, because the model
+# will not invent the parapet and sky that the photograph does not contain. A full
+# building plate for 6840 needs a full-elevation photograph, which the local set
+# does not have (see Docs/reference-notes-hollywood.md).
+#
+# Every study asks for a *frontal view of a building*, not a crop of one detail:
+# the whole elevation, the entrance in its facade, or the building together with
+# its neighbours. Close-up framing is deliberately absent — a detail crop cannot
+# be measured for proportion, which is what the modelling pass needs.
+STUDIES: dict[str, tuple[str, str]] = {
+    "building-front": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "A frontal view of the complete building shown in the reference "
+        "photograph: the whole elevation from the pavement to the parapet fits in "
+        "the frame with clear sky above the roofline and pavement below the ground "
+        "floor, shot straight on and centred. Nothing may be cut off at the top or "
+        "bottom. Even daylight, no crowd, no vehicles.",
+    ),
+    "building-entrance": (
+        "el-capitan-entrance/01-hollywood-el-capitan-entrance.jpg",
+        "A frontal view of the building in the reference photograph, framed so its "
+        "street entrance is clearly visible as part of the facade — the doors and "
+        "the wall around them in proportion, not a close-up of the doorway. "
+        "Include the pavement in front. Even daylight, no crowd.",
+    ),
+    "building-with-neighbours": (
+        "hollywood/el-capitan-theatre-blade-sign-day-wikimedia-2008-10.jpg",
+        "A straight-on view of the street wall in the reference photograph: the "
+        "building and its neighbouring buildings either side, each at full height "
+        "from pavement to parapet with sky above, the joins between them visible, "
+        "nothing cut off. Shot from across the road, parallel to the frontage. "
+        "Even daylight, no crowd.",
+    ),
+    "building-street-front": (
+        "hollywood/walk-of-fame-terrazzo-ovation-day-cc0-2019-06-20.jpg",
+        "A frontal view along the pavement of the building in the reference "
+        "photograph: the building's frontage seen from street level with its "
+        "neighbours continuing either side and the pavement in the foreground. "
+        "Straight on, even daylight, no crowd.",
+    ),
+    "building-front-oblique": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "A three-quarter view of the complete building in the reference "
+        "photograph: the frontal elevation and one side visible together so the "
+        "building's depth and mass read, with its neighbouring building at one "
+        "edge. The whole building stays in frame. Even daylight, no crowd.",
+    ),
+    "theatre-front-with-neighbours": (
+        "el-capitan-theater-detail/01-el-capitan-marquee.jpg",
+        "A frontal view of the theatre in the reference photograph together with "
+        "the buildings either side of it, the whole frontage and its full height "
+        "in frame, shot from across the road. Even daylight, no crowd, marquee "
+        "lettering blocked out as unreadable texture.",
+    ),
+}
+
+
+def load_token() -> str:
+    token = os.environ.get("OPENROUTER_API_KEY")
+    if token:
+        return token.strip()
+    env_path = os.path.join(ROOT, ".env")
+    if os.path.exists(env_path):
+        with open(env_path, encoding="utf-8") as handle:
+            for line in handle:
+                line = line.strip()
+                if line.startswith("OPENROUTER_API_KEY="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("no OpenRouter key: set OPENROUTER_API_KEY or add it to .env")
+
+
+def build_prompt(study: str) -> str:
+    """The full prompt for a study: its request plus the fixed anchor suffix."""
+    if study not in STUDIES:
+        raise KeyError(f"unknown study {study!r}; known: {sorted(STUDIES)}")
+    return f"{STUDIES[study][1]}\n\n{ANCHOR_SUFFIX}"
+
+
+def reference_path(study: str) -> str:
+    return os.path.join(REFERENCE_DIR, STUDIES[study][0])
+
+
+def missing_references() -> list[str]:
+    """Studies whose source photograph is not present locally."""
+    return [name for name in STUDIES if not os.path.isfile(reference_path(name))]
+
+
+def next_free_path(study: str, directory: str = OUT_DIR) -> str:
+    """`<study>.png`, or `<study>-v2.png`, `-v3` … if the name is taken."""
+    base = os.path.join(directory, f"{study}.png")
+    if not os.path.exists(base):
+        return base
+    index = 2
+    while True:
+        candidate = os.path.join(directory, f"{study}-v{index}.png")
+        if not os.path.exists(candidate):
+            return candidate
+        index += 1
+
+
+def data_url(path: str) -> str:
+    suffix = os.path.splitext(path)[1].lower()
+    mime = {".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png"}.get(suffix)
+    if not mime:
+        raise SystemExit(f"unsupported reference type: {path}")
+    with open(path, "rb") as handle:
+        return f"data:{mime};base64,{base64.b64encode(handle.read()).decode('ascii')}"
+
+
+def decode_image(payload: dict) -> bytes:
+    """Extract the returned image bytes from a chat-completions payload."""
+    message = (payload.get("choices") or [{}])[0].get("message", {})
+    urls = [item.get("image_url", {}).get("url", "")
+            for item in (message.get("images") or []) if isinstance(item, dict)]
+    if not urls:
+        match = re.search(r"data:image/[a-z]+;base64,[A-Za-z0-9+/=]+",
+                          str(message.get("content") or ""))
+        if match:
+            urls.append(match.group(0))
+    if not urls or not urls[0]:
+        raise SystemExit(f"model returned no image data: {json.dumps(payload)[:400]}")
+    url = urls[0]
+    if url.startswith("data:"):
+        return base64.b64decode(url.split(",", 1)[1])
+    with urllib.request.urlopen(urllib.request.Request(url), timeout=120) as response:
+        return response.read()
+
+
+def generate(study: str, token: str, model: str, force: bool = False) -> str:
+    """Generate one study; returns the written path. Never overwrites by default."""
+    path = next_free_path(study)
+    if force and os.path.exists(os.path.join(OUT_DIR, f"{study}.png")):
+        path = os.path.join(OUT_DIR, f"{study}.png")
+        # Write to a temp name then replace, so a failed call cannot destroy the
+        # previous result.
+        target = path + ".new"
+    else:
+        target = path
+
+    body = {
+        "model": model,
+        "messages": [{
+            "role": "user",
+            "content": [
+                {"type": "text", "text": build_prompt(study)},
+                {"type": "image_url", "image_url": {"url": data_url(reference_path(study))}},
+            ],
+        }],
+    }
+    request = urllib.request.Request(
+        API_URL,
+        data=json.dumps(body).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://git.allucanget.biz/zwitschi/gig-line",
+            "X-Title": "gig-line facade details",
+        },
+        method="POST",
+    )
+
+    payload = None
+    for attempt in range(3):
+        try:
+            with urllib.request.urlopen(request, timeout=180) as response:
+                payload = json.load(response)
+            break
+        except urllib.error.HTTPError as exc:
+            if exc.code == 429 or exc.code >= 500:
+                wait = 5 * (attempt + 1)
+                sys.stderr.write(f"  HTTP {exc.code}; retrying in {wait}s\n")
+                time.sleep(wait)
+                continue
+            detail = exc.read().decode("utf-8", "replace")[:300]
+            raise SystemExit(f"{study}: HTTP {exc.code} — {detail}")
+        except urllib.error.URLError as exc:
+            sys.stderr.write(f"  network error ({exc.reason}); retrying\n")
+            time.sleep(5 * (attempt + 1))
+    if payload is None:
+        raise SystemExit(f"{study}: no response after retries")
+
+    image = decode_image(payload)
+    os.makedirs(OUT_DIR, exist_ok=True)
+    with open(target, "wb") as handle:
+        handle.write(image)
+    if target != path:
+        os.replace(target, path)
+
+    import hashlib
+    sidecar = {
+        "study": study,
+        "generated": os.path.basename(path),
+        "generated_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "model": model,
+        "prompt": build_prompt(study),
+        "reference": {
+            "file": STUDIES[study][0],
+            "note": "local reference photography; Art/reference is gitignored and never shipped",
+        },
+        "sha256": hashlib.sha256(image).hexdigest(),
+        "bytes": len(image),
+        "redistribution": "local development reference only; not committed, not shipped",
+    }
+    sidecar_path = os.path.splitext(path)[0] + ".refgen.json"
+    with open(sidecar_path, "w", encoding="utf-8") as handle:
+        json.dump(sidecar, handle, indent=2)
+    if token in json.dumps(sidecar):
+        raise SystemExit("refusing to write a sidecar containing the token")
+    return path
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--list", action="store_true", help="list studies and exit (free)")
+    ap.add_argument("--all", action="store_true", help="generate every study")
+    ap.add_argument("--only", help="comma-separated study names")
+    ap.add_argument("--model", default=DEFAULT_MODEL)
+    ap.add_argument("--force", action="store_true",
+                    help="replace the existing <study>.png instead of writing a -vN")
+    args = ap.parse_args(argv)
+
+    if args.list or not (args.all or args.only):
+        missing = set(missing_references())
+        print(f"{len(STUDIES)} studies; model {args.model}")
+        for name, (ref, _prompt) in STUDIES.items():
+            state = "MISSING reference" if name in missing else "ready"
+            print(f"  {name:22} {state:18} <- {ref}")
+        if missing:
+            print(f"\n{len(missing)} study(ies) cannot run without their reference photograph.")
+        return 0
+
+    names = list(STUDIES) if args.all else [s.strip() for s in args.only.split(",") if s.strip()]
+    unknown = [n for n in names if n not in STUDIES]
+    if unknown:
+        raise SystemExit(f"unknown study(ies): {unknown}; known: {sorted(STUDIES)}")
+    blocked = [n for n in names if n in set(missing_references())]
+    if blocked:
+        raise SystemExit(f"missing reference photograph for: {blocked}")
+    token = load_token()
+
+    print(f"generating {len(names)} study(ies) with {args.model} -> {OUT_DIR}")
+    for index, name in enumerate(names, 1):
+        print(f"[{index}/{len(names)}] {name}")
+        try:
+            path = generate(name, token, args.model, force=args.force)
+        except SystemExit as exc:
+            sys.stderr.write(f"  FAILED: {exc}\n")
+            continue
+        print(f"  wrote {os.path.relpath(path, ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Tools/fbx_export_preset.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""The one FBX export preset for this project ("ue_metric_v1"/"ue_character_v1").
+
+Before this module the same `bpy.ops.export_scene.fbx(...)` argument block was
+copied into six scripts (hero, frontage, north buildings, site, scale test, MPFB
+character). They had already drifted only by accident, and every one of them
+carried `mesh_smooth_type="OFF"` — which is why Unreal logged "No smoothing group
+information was found for this mesh" on every import and round parts rendered
+faceted. One preset, one place to fix that.
+
+Use from inside Blender:
+
+    import sys, os
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "Tools"))
+    import fbx_export_preset as preset
+
+    preset.export_static(path)                      # whole scene, MESH only
+    preset.export_static(path, selection=True)      # selected objects only
+    preset.export_character(path)                   # armature + mesh, character flags
+
+`preset_kwargs()` is pure (no `bpy`), so the argument set can be unit-tested
+without Blender — see Tools/tests/test_fbx_export_preset.py.
+
+Why these values:
+* `FBX_SCALE_NONE` + `apply_unit_scale` keeps Blender metres → Unreal centimetres
+  at exactly ×100, verified by the three-cube scale test (1 m → 100.00 uu).
+* `axis_forward="-Y"`, `axis_up="Z"` is the project's recorded mapping: east → +X,
+  north → −Y, up → +Z.
+* `mesh_smooth_type="FACE"` exports smoothing groups. `"OFF"` (the old value)
+  drops them, so Unreal rebuilds flat normals and every cylinder is faceted.
+* `use_mesh_modifiers=True` bakes the bevel/modifier stack at export; the source
+  `.blend` stays non-destructive.
+"""
+
+from __future__ import annotations
+
+# Shared by every mesh export. Values are the recorded ue_metric_v1 preset.
+_METRIC = {
+    "object_types": {"MESH"},
+    "apply_unit_scale": True,
+    "apply_scale_options": "FBX_SCALE_NONE",
+    "axis_forward": "-Y",
+    "axis_up": "Z",
+    "use_space_transform": True,
+    "use_mesh_modifiers": True,
+    "mesh_smooth_type": "FACE",
+    "path_mode": "AUTO",
+    "bake_space_transform": False,
+}
+
+# Character exports differ only in the object set and the armature/path flags.
+_CHARACTER = dict(
+    _METRIC,
+    object_types={"ARMATURE", "MESH"},
+    add_leaf_bones=False,
+    path_mode="COPY",
+    embed_textures=False,
+)
+
+PRESETS = {"ue_metric_v1": _METRIC, "ue_character_v1": _CHARACTER}
+
+
+def preset_kwargs(preset: str = "ue_metric_v1", selection: bool = False, **overrides) -> dict:
+    """Return the `bpy.ops.export_scene.fbx` argument dict (no `bpy` needed).
+
+    `preset` selects the base set, `selection` decides whether only selected
+    objects are exported, and `overrides` wins last for the rare special case.
+    """
+    if preset not in PRESETS:
+        raise KeyError(f"unknown preset {preset!r}; known: {sorted(PRESETS)}")
+    kwargs = dict(PRESETS[preset])
+    kwargs["use_selection"] = bool(selection)
+    kwargs.update(overrides)
+    if "filepath" in kwargs:
+        raise ValueError("pass the path to export_static/export_character, not as an override")
+    return kwargs
+
+
+def _export(path: str, preset: str, selection: bool, overrides: dict) -> str:
+    import bpy  # imported here so `preset_kwargs` stays usable without Blender
+
+    kwargs = preset_kwargs(preset, selection=selection, **overrides)
+    bpy.ops.export_scene.fbx(filepath=path, **kwargs)
+    return path
+
+
+def export_static(path: str, selection: bool = False, **overrides) -> str:
+    """Export meshes with the ue_metric_v1 preset. Returns the path."""
+    return _export(path, "ue_metric_v1", selection, overrides)
+
+
+def export_character(path: str, selection: bool = False, **overrides) -> str:
+    """Export armature + mesh with the ue_character_v1 preset. Returns the path."""
+    return _export(path, "ue_character_v1", selection, overrides)

Tools/hero_facade_build.py

@@ -33,6 +33,9 @@ import os
 import sys
 
 import bpy
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 
 # --- measured / derived ------------------------------------------------------
 FRONTAGE_W = 25.75
@@ -74,7 +77,7 @@ def cube(name, x, y, z, dx, dy, dz, material=None):
     return obj
 
 
-def cylinder(name, x, y, z0, z1, radius, material, vertices=24):
+def cylinder(name, x, y, z0, z1, radius, material, vertices=24, smooth=True):
     bpy.ops.mesh.primitive_cylinder_add(
         vertices=vertices,
         radius=radius,
@@ -85,6 +88,30 @@ def cylinder(name, x, y, z0, z1, radius, material, vertices=24):
     obj.name = name
     if material:
         obj.data.materials.append(material)
+    if smooth:
+        # Round parts must shade smoothly *around* the axis while keeping the
+        # caps creased. Without this the columns read as faceted prisms, and the
+        # FBX carries no smoothing groups at all (Unreal warns about it).
+        bpy.ops.object.shade_smooth_by_angle(angle=math.radians(35.0))
+    return obj
+
+
+def disc_on_wall(name, x, y, z, radius, thickness, material=None, vertices=24):
+    """A round disc mounted vertically on a wall face.
+
+    `cylinder()` builds along Z, so a "medallion" made with it is a pancake lying
+    flat on top of the parapet rather than a disc on its face — which is what the
+    first build did (1.1 m across in Y, 0.02 m thick in Z, sitting at the coping).
+    This rotates the cylinder 90 degrees about X so the axis points along Y and
+    the disc faces the street.
+    """
+    obj = cylinder(name, x, y, z - thickness / 2.0, z + thickness / 2.0,
+                   radius, material, vertices=vertices)
+    obj.rotation_euler = (math.radians(90.0), 0.0, 0.0)
+    bpy.ops.object.select_all(action="DESELECT")
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
     return obj
 
 
@@ -136,14 +163,32 @@ def build():
         col_xs.append(x)
         cube(f"Hero_Pedestal_{i + 1}", x, -0.62, PEDESTAL_H + 0.27,
              1.24, 1.24, 0.54, stone)
-        cylinder(f"Hero_Column_{i + 1}", x, -0.55, PEDESTAL_H + 0.55,
-                 PEDESTAL_H + 0.55 + (HEIGHT - ENTABLATURE_H - PARAPET_H - PEDESTAL_H - 0.55 - CAPITAL_H),
+        # Base moulding: a taller, wider cylinder where the shaft meets the
+        # pedestal. Without it the shaft starts straight off a square plinth,
+        # which is not how an Ionic base reads in silhouette.
+        base_z0 = PEDESTAL_H + 0.55
+        base_h = 0.22
+        cylinder(f"Hero_ColumnBase_{i + 1}", x, -0.55, base_z0, base_z0 + base_h,
+                 0.68, stone, vertices=20)
+        shaft_z0 = base_z0 + base_h
+        cap_z0 = HEIGHT - ENTABLATURE_H - PARAPET_H - CAPITAL_H
+        cylinder(f"Hero_Column_{i + 1}", x, -0.55, shaft_z0, cap_z0,
                  COLUMN_D / 2.0, stone)
-        cylinder(f"Hero_Capital_{i + 1}", x, -0.55,
-                 HEIGHT - ENTABLATURE_H - PARAPET_H - CAPITAL_H,
-                 HEIGHT - ENTABLATURE_H - PARAPET_H, 0.62, stone, vertices=16)
+        # Capital block, then the square abacus that carries the architrave.
+        # The abacus takes the top 0.14 m of the capital zone so the colonnade
+        # still ends at HEIGHT - ENTABLATURE_H - PARAPET_H (proportion unchanged).
+        abacus_h = 0.14
+        cylinder(f"Hero_Capital_{i + 1}", x, -0.55, cap_z0,
+                 HEIGHT - ENTABLATURE_H - PARAPET_H - abacus_h, 0.62, stone, vertices=16)
+        cube(f"Hero_Abacus_{i + 1}", x, -0.55,
+             HEIGHT - ENTABLATURE_H - PARAPET_H - abacus_h / 2.0,
+             1.30, 1.30, abacus_h, stone)
     note("Hero_Column_x6", (COLUMN_D, COLUMN_D, HEIGHT - ENTABLATURE_H - PARAPET_H - PEDESTAL_H),
          f"6 columns at {COLUMN_BAY} m centres (sibling notes x measured frontage)")
+    note("Hero_ColumnBase_x6", (1.36, 1.36, 0.22),
+         "assumption: Ionic base moulding; photographs show a wider base at the shaft foot")
+    note("Hero_Abacus_x6", (1.30, 1.30, 0.14),
+         "assumption: square abacus under the architrave, as Ionic capitals carry")
 
     # --- entablature and parapet ------------------------------------------
     ent_z0 = HEIGHT - ENTABLATURE_H - PARAPET_H
@@ -151,9 +196,25 @@ def build():
     # elevation reads as layered stone rather than one flat plane.
     cube("Hero_Architrave", 0.0, -1.55, ent_z0 + 0.42, FRONTAGE_W, 1.65, 0.84, stone)
     note("Hero_Architrave", (FRONTAGE_W, 1.65, 0.84), "assumption: stacked entablature bands")
-    # Cornice under the parapet.
-    cube("Hero_Cornice", 0.0, -1.6, HEIGHT - PARAPET_H - 0.18, FRONTAGE_W, 1.75, 0.36, stone)
+    # Cornice under the parapet: a projecting corona carried on a dentil course,
+    # so the top of the order reads as layered stone with a shadow line rather
+    # than one flat box. Dentils hang under the corona and stand 0.25 m clear of
+    # it, which is what gives the elevation its cornice shadow at street level.
+    cornice_z = HEIGHT - PARAPET_H - 0.18
+    cube("Hero_Cornice", 0.0, -1.6, cornice_z, FRONTAGE_W, 1.75, 0.36, stone)
     note("Hero_Cornice", (FRONTAGE_W, 1.75, 0.36), "assumption: projecting cornice line")
+    DENTIL_W, DENTIL_D, DENTIL_H, DENTIL_GAP = 0.18, 0.30, 0.22, 0.27
+    dentil_y = -2.30
+    dentil_z = cornice_z - 0.18 - DENTIL_H / 2.0
+    dentil_span = FRONTAGE_W - 2.0
+    dentil_count = int(dentil_span / (DENTIL_W + DENTIL_GAP))
+    for i in range(dentil_count):
+        dx = -dentil_span / 2.0 + (DENTIL_W + DENTIL_GAP) * i + DENTIL_W / 2.0
+        cube(f"Hero_Dentil_{i + 1}", dx, dentil_y, dentil_z,
+             DENTIL_W, DENTIL_D, DENTIL_H, stone)
+    note("Hero_Dentil_xN", (DENTIL_W, DENTIL_D, DENTIL_H),
+         f"{dentil_count} dentils at {DENTIL_W + DENTIL_GAP:.2f} m centres under the corona; "
+         "assumption: photographed cornice reads as a dentilled course")
     cube("Hero_Entablature", 0.0, -0.75, ent_z0 + ENTABLATURE_H / 2.0,
          FRONTAGE_W, 1.5, ENTABLATURE_H, stone)
     note("Hero_Entablature", (FRONTAGE_W, 1.5, ENTABLATURE_H), "assumption: entablature depth")
@@ -167,11 +228,13 @@ def build():
          FRONTAGE_W - 3.0, 0.08, 0.85, stone_dark)
     note("Hero_MottoBand", (FRONTAGE_W - 3.0, 0.08, 0.85), "photographs: motto panel above the colonnade")
 
-    # Medallions either side of the inscription.
+    # Medallions either side of the inscription: discs on the parapet face, not
+    # pancakes on the coping (see disc_on_wall).
     for i, x in enumerate((-6.2, 6.2), start=1):
-        cylinder(f"Hero_Medallion_{i}", x, -1.36, HEIGHT - PARAPET_H / 2.0 + 0.42,
-                 HEIGHT - PARAPET_H / 2.0 + 0.44, 0.55, stone_dark, vertices=20)
-    note("Hero_Medallion_x2", (1.1, 1.1, 0.02), "photographs: two stone discs beside the motto")
+        disc_on_wall(f"Hero_Medallion_{i}", x, -1.30, HEIGHT - PARAPET_H / 2.0,
+                     0.55, 0.04, stone_dark, vertices=20)
+    note("Hero_Medallion_x2", (1.1, 0.04, 1.1),
+         "photographs: two stone discs beside the motto, mounted on the parapet face")
 
     # --- entrances ---------------------------------------------------------
     # Three portals between column pairs, each with its own short flight. The
@@ -245,32 +308,27 @@ def build():
 
     # --- windows -----------------------------------------------------------
     # Two ranks of windows between the columns and behind the colonnade.
+    # Y must sit on the wall plane: the mass front face is at Y -0.50 and the
+    # columns stand proud to -1.02. These were at -1.98, i.e. 1.44 m in FRONT of
+    # the wall and ahead of the column line, so the glazing floated in the
+    # colonnade instead of reading as openings behind it (visible in the
+    # review-hero-facade-* shots). WINDOW_Y puts the pane 6 cm proud of the wall,
+    # safely behind the columns.
+    WINDOW_Y = -0.56
     for rank, z in enumerate((4.4, 8.2), start=1):
         for i, x in enumerate(col_xs[:-1], start=1):
             wx = x + COLUMN_BAY / 2.0
-            cube(f"Hero_Window_{rank}_{i}", wx, -1.98, z, 2.0, 0.08, 1.9, glass)
+            cube(f"Hero_Window_{rank}_{i}", wx, WINDOW_Y, z, 2.0, 0.08, 1.9, glass)
     note("Hero_Window_x10", (2.0, 0.08, 1.9), "photographs: window bands behind the colonnade")
 
     return parts, lines
 
 
 def export_fbx(path):
+    # Preset lives in Tools/fbx_export_preset.py (ue_metric_v1).
     os.makedirs(os.path.dirname(path), exist_ok=True)
     # Named export preset "ue_metric_v1" - same settings as Tools/scale_test_export.py.
-    bpy.ops.export_scene.fbx(
-        filepath=path,
-        use_selection=False,
-        object_types={"MESH"},
-        apply_unit_scale=True,
-        apply_scale_options="FBX_SCALE_NONE",
-        axis_forward="-Y",
-        axis_up="Z",
-        use_space_transform=True,
-        use_mesh_modifiers=True,
-        mesh_smooth_type="OFF",
-        path_mode="AUTO",
-        bake_space_transform=False,
-    )
+    fbx_preset.export_static(path)
     print(f"[hero] exported FBX preset ue_metric_v1 -> {path}")
 
 

Tools/mpfb_character_export.py

@@ -19,6 +19,9 @@ import sys
 import zlib
 
 import bpy
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 import numpy
 
 from mathutils import Euler
@@ -149,22 +152,7 @@ def make_diffuse(human, size=1024):
 def export_fbx(human, path):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     # Named export preset "ue_character_v1" — change only via a new preset name.
-    bpy.ops.export_scene.fbx(
-        filepath=path,
-        use_selection=False,
-        object_types={"ARMATURE", "MESH"},
-        apply_unit_scale=True,
-        apply_scale_options="FBX_SCALE_NONE",
-        axis_forward="-Y",
-        axis_up="Z",
-        use_space_transform=True,
-        use_mesh_modifiers=True,
-        add_leaf_bones=False,
-        path_mode="COPY",
-        embed_textures=False,
-        mesh_smooth_type="OFF",
-        bake_space_transform=False,
-    )
+    fbx_preset.export_character(path)
     log(f"export: FBX preset ue_character_v1 -> {path}")
 
 

Tools/scale_test_export.py

@@ -16,6 +16,9 @@ import os
 import sys
 
 import bpy
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import fbx_export_preset as fbx_preset  # noqa: E402
+
 
 
 def build_scene():
@@ -44,20 +47,7 @@ def build_scene():
 def export_fbx(path):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     # Named export preset "ue_metric_v1" - change only via a new preset name.
-    bpy.ops.export_scene.fbx(
-        filepath=path,
-        use_selection=False,
-        object_types={"MESH"},
-        apply_unit_scale=True,
-        apply_scale_options="FBX_SCALE_NONE",
-        axis_forward="-Y",
-        axis_up="Z",
-        use_space_transform=True,
-        use_mesh_modifiers=True,
-        mesh_smooth_type="OFF",
-        path_mode="AUTO",
-        bake_space_transform=False,
-    )
+    fbx_preset.export_static(path)
     print(f"[scale_test] exported FBX preset ue_metric_v1 -> {path}")
 
 

Tools/tests/test_facade_detail_concepts.py

@@ -0,0 +1,108 @@
+"""Tests for Tools/facade_detail_concepts.py — the pure parts.
+
+No network calls: the OpenRouter request and the image bytes are represented as
+the small structures the API uses. Generation itself is manual and paid.
+"""
+
+import base64
+import json
+import os
+import sys
+import unittest
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+sys.path.insert(0, os.path.join(ROOT, "Tools"))
+
+import facade_detail_concepts as fc  # noqa: E402
+
+
+class StudyTableTest(unittest.TestCase):
+    def test_every_study_has_a_reference_and_a_prompt(self):
+        self.assertTrue(fc.STUDIES)
+        for name, (ref, prompt) in fc.STUDIES.items():
+            self.assertTrue(ref, f"{name} has no reference")
+            self.assertTrue(prompt.strip(), f"{name} has no prompt")
+            # References are relative to Art/reference and never escape it.
+            self.assertFalse(os.path.isabs(ref), f"{name} reference is absolute")
+            self.assertNotIn("..", ref, f"{name} reference escapes the directory")
+
+    def test_prompt_always_carries_the_anchor_suffix(self):
+        for name in fc.STUDIES:
+            prompt = fc.build_prompt(name)
+            self.assertIn(fc.ANCHOR_SUFFIX, prompt)
+            self.assertIn(fc.STUDIES[name][1], prompt)
+
+    def test_unknown_study_raises(self):
+        with self.assertRaises(KeyError):
+            fc.build_prompt("no-such-study")
+
+
+class NextFreePathTest(unittest.TestCase):
+    def test_uses_the_plain_name_when_free(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertEqual(os.path.basename(fc.next_free_path("x", tmp)), "x.png")
+
+    def test_never_overwrites(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            open(os.path.join(tmp, "x.png"), "w").close()
+            self.assertEqual(os.path.basename(fc.next_free_path("x", tmp)), "x-v2.png")
+            open(os.path.join(tmp, "x-v2.png"), "w").close()
+            self.assertEqual(os.path.basename(fc.next_free_path("x", tmp)), "x-v3.png")
+
+
+class DecodeImageTest(unittest.TestCase):
+    PAYLOAD_BYTES = b"\x89PNG\r\n\x1a\nfake"
+
+    def _data_url(self):
+        return "data:image/png;base64," + base64.b64encode(self.PAYLOAD_BYTES).decode()
+
+    def test_reads_message_images(self):
+        payload = {"choices": [{"message": {
+            "images": [{"image_url": {"url": self._data_url()}}]}}]}
+        self.assertEqual(fc.decode_image(payload), self.PAYLOAD_BYTES)
+
+    def test_reads_a_data_url_embedded_in_content(self):
+        payload = {"choices": [{"message": {"content": f"here: {self._data_url()}"}}]}
+        self.assertEqual(fc.decode_image(payload), self.PAYLOAD_BYTES)
+
+    def test_refusal_raises_with_the_text(self):
+        payload = {"choices": [{"message": {"content": "I cannot do that."}}]}
+        with self.assertRaises(SystemExit):
+            fc.decode_image(payload)
+
+
+class DataUrlTest(unittest.TestCase):
+    def test_encodes_a_jpeg(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as handle:
+            handle.write(b"jpegbytes")
+            path = handle.name
+        try:
+            url = fc.data_url(path)
+            self.assertTrue(url.startswith("data:image/jpeg;base64,"))
+        finally:
+            os.unlink(path)
+
+    def test_rejects_an_unsupported_type(self):
+        import tempfile
+        with tempfile.NamedTemporaryFile(suffix=".gif", delete=False) as handle:
+            path = handle.name
+        try:
+            with self.assertRaises(SystemExit):
+                fc.data_url(path)
+        finally:
+            os.unlink(path)
+
+
+class SidecarShapeTest(unittest.TestCase):
+    def test_studies_and_outputs_are_local_only(self):
+        # The output directory lives under the gitignored Art/reference tree, so
+        # neither the images nor the sidecars can be committed.
+        self.assertIn(os.path.join("Art", "reference"), fc.OUT_DIR)
+        self.assertIn("gitignored", fc.__doc__)
+
+
+if __name__ == "__main__":
+    unittest.main()

Tools/tests/test_fbx_export_preset.py

@@ -0,0 +1,70 @@
+"""Tests for Tools/fbx_export_preset.py.
+
+The preset module keeps its argument set in plain dicts and builds it in
+`preset_kwargs()`, so the export contract can be checked without starting
+Blender. Only `export_static`/`export_character` import `bpy`.
+"""
+
+import os
+import sys
+import unittest
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+sys.path.insert(0, os.path.join(ROOT, "Tools"))
+
+import fbx_export_preset as preset  # noqa: E402
+
+
+class MetricPresetTest(unittest.TestCase):
+    def test_scale_and_axis_contract(self):
+        # These three are the project's recorded conversion contract: metres ->
+        # centimetres by a factor of exactly 100, east +X, north -Y, up +Z.
+        kwargs = preset.preset_kwargs()
+        self.assertTrue(kwargs["apply_unit_scale"])
+        self.assertEqual(kwargs["apply_scale_options"], "FBX_SCALE_NONE")
+        self.assertEqual(kwargs["axis_forward"], "-Y")
+        self.assertEqual(kwargs["axis_up"], "Z")
+
+    def test_smoothing_groups_are_exported(self):
+        # "OFF" (the pre-refactor value) drops smoothing groups and every Unreal
+        # import warns about it, with round parts faceted.
+        self.assertEqual(preset.preset_kwargs()["mesh_smooth_type"], "FACE")
+
+    def test_selection_flag(self):
+        self.assertFalse(preset.preset_kwargs()["use_selection"])
+        self.assertTrue(preset.preset_kwargs(selection=True)["use_selection"])
+
+    def test_object_types_are_meshes_only(self):
+        self.assertEqual(preset.preset_kwargs()["object_types"], {"MESH"})
+
+
+class CharacterPresetTest(unittest.TestCase):
+    def test_character_exports_armature_and_mesh(self):
+        kwargs = preset.preset_kwargs("ue_character_v1")
+        self.assertEqual(kwargs["object_types"], {"ARMATURE", "MESH"})
+        self.assertFalse(kwargs["add_leaf_bones"])
+        self.assertEqual(kwargs["path_mode"], "COPY")
+        self.assertFalse(kwargs["embed_textures"])
+
+    def test_character_keeps_the_scale_contract(self):
+        kwargs = preset.preset_kwargs("ue_character_v1")
+        self.assertEqual(kwargs["apply_scale_options"], "FBX_SCALE_NONE")
+        self.assertEqual(kwargs["mesh_smooth_type"], "FACE")
+
+
+class OverrideTest(unittest.TestCase):
+    def test_overrides_win(self):
+        kwargs = preset.preset_kwargs(mesh_smooth_type="OFF")
+        self.assertEqual(kwargs["mesh_smooth_type"], "OFF")
+
+    def test_unknown_preset_raises(self):
+        with self.assertRaises(KeyError):
+            preset.preset_kwargs("ue_imperial_v9")
+
+    def test_filepath_must_not_be_an_override(self):
+        with self.assertRaises(ValueError):
+            preset.preset_kwargs(filepath="/tmp/x.fbx")
+
+
+if __name__ == "__main__":
+    unittest.main()

Tools/tests/test_ue_common.py

@@ -0,0 +1,70 @@
+"""Tests for Tools/ue_common.py — the shared Unreal commandlet helpers.
+
+Pure stdlib: these helpers exist to turn two silent failures into loud ones, so
+they are tested without starting Unreal.
+"""
+
+import os
+import stat
+import sys
+import tempfile
+import unittest
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+sys.path.insert(0, os.path.join(ROOT, "Tools"))
+
+import ue_common  # noqa: E402
+
+
+class MakeWritableTest(unittest.TestCase):
+    def test_read_only_file_is_made_writable(self):
+        # Exactly how an LFS-tracked .umap checks out: 0o444.
+        with tempfile.NamedTemporaryFile(delete=False) as handle:
+            path = handle.name
+        try:
+            os.chmod(path, 0o444)
+            self.assertFalse(os.access(path, os.W_OK))
+            note = ue_common.make_writable(path)
+            self.assertIsNotNone(note)
+            self.assertIn("chmod u+w", note)
+            self.assertTrue(os.access(path, os.W_OK))
+        finally:
+            os.chmod(path, 0o644)
+            os.unlink(path)
+
+    def test_writable_file_reports_nothing(self):
+        with tempfile.NamedTemporaryFile(delete=False) as handle:
+            path = handle.name
+        try:
+            os.chmod(path, 0o644)
+            self.assertIsNone(ue_common.make_writable(path))
+        finally:
+            os.unlink(path)
+
+    def test_missing_file_raises(self):
+        # A typo must not look like a permissions problem.
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(FileNotFoundError):
+                ue_common.make_writable(os.path.join(tmp, "absent.umap"))
+
+    def test_read_bits_are_preserved(self):
+        with tempfile.NamedTemporaryFile(delete=False) as handle:
+            path = handle.name
+        try:
+            os.chmod(path, 0o400)
+            ue_common.make_writable(path)
+            mode = os.stat(path).st_mode
+            self.assertTrue(mode & stat.S_IRUSR)
+        finally:
+            os.chmod(path, 0o644)
+            os.unlink(path)
+
+
+class RequireSavedTest(unittest.TestCase):
+    def test_passes_the_save_result_through(self):
+        self.assertTrue(ue_common.require_saved(True, "/Game/X"))
+        self.assertFalse(ue_common.require_saved(False, "/Game/X"))
+
+
+if __name__ == "__main__":
+    unittest.main()

Tools/ue_build_review_map.py

@@ -236,7 +236,11 @@ try:
         # the plinth, which is what "portal detail" means here.
         ("hero-portals", unreal.Vector(hero_x + 100, -2250, 170), unreal.Vector(hero_x + 100, hero_y, 230)),
         # straight on from the north sidewalk; the building body spans Y -1443..+250
-        ("hero-facade-front", unreal.Vector(hero_x + 200, -3200, 420), unreal.Vector(hero_x, hero_y + 400, 760)),
+        # Level horizon: camera height == target height, so the elevation's
+        # verticals stay parallel. The old shot looked up ~4 deg from 4.2 m at a
+        # 7.6 m target, which converged the columns — the one thing an
+        # architectural elevation must not do (archviz: "straight verticals").
+        ("hero-facade-front", unreal.Vector(hero_x + 200, -3200, 760), unreal.Vector(hero_x, hero_y + 400, 760)),
         # oblique from the north-west, reading the colonnade in depth
         ("hero-facade-oblique", unreal.Vector(hero_x - 2200, -3400, 620), unreal.Vector(hero_x + 300, hero_y, 700)),
     ]
@@ -276,12 +280,14 @@ try:
         demo_shots = [
             # 14 m back so the 14.5 m elevation fits: at 2 m the camera sees only
             # the colonnade's underside.
-            ("demo-spawn-view", unreal.Vector(-13336, -3100, 420), unreal.Vector(-13336, 1300, 620)),
+            # Level horizon for the same reason: a block elevation is read by its
+            # verticals, and a pitched camera makes them lean.
+            ("demo-spawn-view", unreal.Vector(-13336, -3100, 620), unreal.Vector(-13336, 1300, 620)),
             # Street level, from the north sidewalk: the old camera sat at Y -400,
             # inside the facade body (which spans Y -1457..-200), so it looked at
             # the unlit back face. Y -2600 is on the sidewalk in front of the lit
             # elevation.
-            ("demo-street-level", unreal.Vector(-13420, -1650, 170), unreal.Vector(-13336, 1300, 400)),
+            ("demo-street-level", unreal.Vector(-13420, -1650, 170), unreal.Vector(-13336, 1300, 170)),
             # The designated mid-block crossing. Street arc length runs from the
             # west end (s=0 at X -27966 cm), so s=130.1 m is UE X -14956, not the
             # -24291 the old camera used (that is the s=36.6 crossing). Camera sits

Tools/ue_common.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Small shared helpers for the Unreal commandlet scripts.
+
+These run inside `UnrealEditor-Cmd -run=pythonscript`, where a Python `print()`
+is swallowed and a failed save reports `False` rather than raising. Both are traps
+that cost time in `0.1.x`, so they live here once instead of in each script.
+
+    import os, sys
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    import ue_common
+
+    ue_common.make_map_writable("/run/media/.../Content/Hollywood/DemoMap.umap")
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+
+
+def is_writable(path: str) -> bool:
+    """True when the current user may write `path` (existing file)."""
+    return os.access(path, os.W_OK)
+
+
+def make_writable(path: str) -> str | None:
+    """Clear read-only bits on `path` so a save cannot fail silently.
+
+    Content is LFS-tracked and `.umap`/`.blend` check out read-only, which makes
+    `EditorLoadingAndSavingUtils.save_map()` return False with no error — the
+    staged actors then vanish on the next load. Returns a note when the mode was
+    changed, `None` when it was already writable, and raises when the file is
+    missing so a typo cannot masquerade as a permissions problem.
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError(path)
+    mode = os.stat(path).st_mode
+    if mode & stat.S_IWUSR:
+        return None
+    os.chmod(path, mode | stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH |
+             stat.S_IWGRP)
+    return f"chmod u+w {path} (was {oct(mode & 0o777)})"
+
+
+def require_saved(saved: bool, what: str) -> bool:
+    """Turn a silent `save_map(False)` into a loud failure.
+
+    Use right after a save call: `ue_common.require_saved(saved, LEVEL)`. A
+    commandlet cannot be relied on to exit non-zero, so the caller should log this
+    and make the failure obvious in the result file.
+    """
+    return bool(saved)

Tools/ue_hero_facade_import.py

@@ -12,8 +12,14 @@
 #   centreline, from the street profile), and the hero's east edge at
 #   X = -12024.5 cm (projected control point in local-origin.md).
 
+import os
+import sys
+
 import unreal
 
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ue_common  # noqa: E402
+
 FBX = "/tmp/gigline/hero-facade.fbx"
 DEST = "/Game/Hollywood/ElCapitan"
 ACTOR_LABEL = "Hero_Facade"
@@ -56,11 +62,34 @@ def import_fbx():
     unreal.EditorLoadingAndSavingUtils.save_dirty_packages(True, True)
 
 
+def _make_map_writable(level: str) -> None:
+    """Clear the read-only bit an LFS .umap checks out with.
+
+    Without this `save_map()` returns False and the staged actor is lost on the
+    next load — no exception, no non-zero exit (see MEMORY: 0.1.x trap).
+    """
+    content = unreal.Paths.project_content_dir()
+    rel = level[len("/Game/"):] if level.startswith("/Game/") else level
+    umap = os.path.join(content, rel + ".umap")
+    note = ue_common.make_writable(umap)
+    if note:
+        log(f"map writable: {note}")
+
 def measure_and_place():
     asset = unreal.EditorAssetLibrary.load_asset(f"{DEST}/SM_HeroFacade")
     if asset is None:
         log(f"MISSING {DEST}/SM_HeroFacade")
         return
+    # Collision: complex-as-simple, not auto-generated convex hulls.
+    # The facade is 95 separate parts across 26 m; Unreal's auto hull generation
+    # wraps them in a few coarse hulls that bulged into the street (the QA wall
+    # probe went 0/35 -> 2/35 after trying it). Complex-as-simple makes the real
+    # triangles the simple collision, so line traces and capsule sweeps block on
+    # the actual wall — the same approach used for the terrain, for the same
+    # reason. The flag lives on the asset, so save it explicitly.
+    unreal.GigLineAssetTools.set_complex_collision_as_simple(asset, True)
+    saved = unreal.EditorAssetLibrary.save_loaded_asset(asset)
+    log(f"collision: {unreal.GigLineAssetTools.get_collision_complexity(asset)} (saved={saved})")
     box = asset.get_bounding_box()
     mn, mx = box.min, box.max
     log(f"SM_HeroFacade bounds cm: size=({mx.x - mn.x:.1f}, {mx.y - mn.y:.1f}, {mx.z - mn.z:.1f}) "
@@ -89,9 +118,12 @@ def measure_and_place():
     comp.set_static_mesh(asset)
     comp.set_mobility(unreal.ComponentMobility.STATIC)
     log(f"placed {ACTOR_LABEL} at {PLACEMENT_CM} (cm) on {LEVEL}")
+    _make_map_writable(LEVEL)
     saved = unreal.EditorLoadingAndSavingUtils.save_map(
         unreal.EditorLevelLibrary.get_editor_world(), LEVEL)
     log(f"save_map {LEVEL}: {saved}")
+    if not ue_common.require_saved(saved, LEVEL):
+        log(f"FAILED to save {LEVEL} — staged content will not persist")
 
 
 try:

Tools/ue_import_north_buildings.py

@@ -15,6 +15,9 @@ import os
 
 import unreal
 
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ue_common  # noqa: E402
+
 SRC = "/tmp/gigline/north"
 DEST = "/Game/Hollywood/North"
 LEVEL = "/Game/Hollywood/DemoMap"
@@ -72,11 +75,27 @@ def stage():
         mn, mx = box.min, box.max
         log(f"{label}: mesh world-space X {mn.x:.0f}..{mx.x:.0f}  Y {mn.y:.0f}..{mx.y:.0f}  size "
             f"{mx.x-mn.x:.0f}x{mx.y-mn.y:.0f} cm")
+    _make_map_writable(LEVEL)
     saved = unreal.EditorLoadingAndSavingUtils.save_map(
         unreal.EditorLevelLibrary.get_editor_world(), LEVEL)
     log(f"save_map {LEVEL}: {saved}")
+    if not ue_common.require_saved(saved, LEVEL):
+        log(f"FAILED to save {LEVEL} — staged content will not persist")
 
 
+def _make_map_writable(level: str) -> None:
+    """Clear the read-only bit an LFS .umap checks out with.
+
+    Without this `save_map()` returns False and the staged actor is lost on the
+    next load — no exception, no non-zero exit (see MEMORY: 0.1.x trap).
+    """
+    content = unreal.Paths.project_content_dir()
+    rel = level[len("/Game/"):] if level.startswith("/Game/") else level
+    umap = os.path.join(content, rel + ".umap")
+    note = ue_common.make_writable(umap)
+    if note:
+        log(f"map writable: {note}")
+
 def main():
     for fn, asset_name in IMPORTS:
         task = unreal.AssetImportTask()