memory: detail-plate toolchain, prompt-refusal gotcha, floating-window fix

Adds Tools/facade_detail_concepts.py: generates architectural detail plates from a
local reference photograph through OpenRouter's image models. Spec-driven (eight
studies: door recess, entrance, column order, entablature/cornice, parapet/motto,
window rhythm, street wall, banner), never overwrites (writes -vN), writes a
.refgen.json sidecar (model, prompt, source photo, SHA-256) per image, and keeps
all output under the gitignored Art/reference/facade-details/ - local only, never
shipped. Stdlib only; http 429/5xx back-off; refuses to write a sidecar containing
the token. 11 tests cover the study table, prompt assembly, next-free naming,
data-URL decoding (both response shapes plus a refusal) and the local-only rule.

Measurement pass on the plates: the hero window panes were at Y -1.98, i.e. 1.44 m
in FRONT of the wall (Y -0.50) and ahead of the column line, so the glazing floated
in the colonnade instead of reading as openings behind it. Moved to Y -0.56; hero
rebuilt, re-imported, DemoMap rebuilt, full screenshot set re-rendered.

Docs: Tools/README row, Screenshots README known-issues entry now records the fix.

.gitignore

@@ -42,6 +42,11 @@ Thumbs.db
 .env.*
 *.env
 
+# Mapbox-derived data — local only. Mapbox terms restrict persisting/redistributing
+# their data, so the Tilequery cache and any generated report stay untracked.
+/Geo/raw/mapbox-cache/
+/Geo/verification/*mapbox*
+
 # Local, private reference material — never committed (see Docs/reference-notes-hollywood.md)
 /Art/reference/
 /Docs/data-inventory.md

AGENTS.md

@@ -110,6 +110,59 @@ Keep entries short and dated, with the evidence: the command, the log line, or t
 
 Memory edits on an agent's branch are not shared live. Communicate important findings to the coordinator during work and reconcile them into the shared `main` copy when integrating.
 
+## Python and shell tooling
+
+Every committed asset and every measured claim in this repository is produced by a script. Tools live in `Tools/` (Unreal, network, repository), `Geo/tools/` (projection, OSM/DEM parsing, metadata) and `Art/blender/*/` (Blender-side builders, next to their output).
+
+**Fix the tool, not the artefact.** If an asset is corrected by hand, script the correction (or regenerate it) in the same change. A second manual fix of the same kind means the tool is missing a step.
+
+**Improve over fork.** Extend the existing tool rather than adding a near-duplicate. When two or three scripts start sharing logic, factor the shared part into `Tools/_common.py`, `Geo/tools/osm_common.py` or `Art/blender/common.py`; keep the single metres→centimetres conversion where it already lives.
+
+Rules that keep tools reusable and reviewable:
+
+- **One script, one job.** Every input is an argument; no interactive prompts; deterministic output paths.
+- **Fail loudly.** A tool that cannot do its job exits non-zero with a message. Never leave a partially written asset and a success code.
+- **Result files for Unreal.** Unreal commandlets swallow `print()`; write the outcome to `/tmp/gigline/<tool>.txt` and read that instead of trusting the exit code alone.
+- **Absolute paths into sandboxes.** Blender Flatpak (`LD_LIBRARY_PATH="$B/blender/lib"`) and Unreal do not share the repo's working directory; pass absolute paths.
+- **Clean worktree for generators.** Tools that rewrite committed assets (site/street/hero builders, importers, map builders) run from a clean worktree; inspect the LFS diff before committing. Note that `.blend` and `.umap` check out read-only — `chmod u+w` first or the save silently fails.
+- **Network and paid-API tools are human-triggered.** `Tools/commons_fetch.py`, `Tools/page_image_fetch.py`, `Tools/judge_screenshot.py` (OpenRouter) and anything similar never sit in a gate or CI. Handle HTTP 429 with back-off rather than retrying immediately.
+- **Measure, don't assert.** Verification tools print the sampled numbers — counts, holes, Z ranges, worst step and its location, frame-time percentiles — so a claim in `TODO.md`, `CHANGELOG.md` or `Docs/` can be re-checked by re-running the command.
+
+**Document every tool.** A new or changed tool gets a row in the inventory table of the README beside it: [`Tools/README.md`](Tools/README.md), [`Geo/README.md`](Geo/README.md), or [`Art/blender/README.md`](Art/blender/README.md). What it does, its arguments, and a typical command. A tool without a README row is unfinished.
+
+**Test the pure parts.** `Tools/tests/` holds stdlib `unittest` tests (no Blender or Unreal process; they must not start a game or editor). Extract the testable core — argument parsing, geometry maths, licence gating, report formatting — into functions that a test can call directly.
+
+```bash
+python3 -m unittest discover -s Tools/tests -t Tools -p 'test_*.py'
+```
+
+Keep the tools standard-library-only where practical; if a third-party import is genuinely needed, add it to `requirements-tools.txt` with a version floor and mention it in the tool's README row.
+
+## Architecture documentation
+
+[`Docs/Architecture/`](Docs/Architecture/) is the arc42 documentation: twelve numbered section files, `about-arc42.md`, and the combined [`architecture.md`](Docs/Architecture/architecture.md). **Markdown is canonical** — the `.adoc` sources were removed on 2026-11-08.
+
+Keep it current **in the same change as the implementation**, not in a later documentation pass. When work alters any of the following, edit the matching section:
+
+| Change | Section |
+| --- | --- |
+| A new or restructured module, tool, data source or external interface | `05_building_block_view.md` |
+| A runtime flow, tick/order dependency, or lifecycle (possession, map load, QA self-test) | `06_runtime_view.md` |
+| Packaging, engine pin, checkout/build/launch procedure | `07_deployment_view.md` |
+| A pattern, convention or cross-cutting rule (units, collision policy, provenance) | `08_concepts.md` |
+| A decision that constrains future work | new ADR in `09_architecture_decisions.md` |
+| A quality goal or a measured budget (frame time, traversal coverage) | `10_quality_requirements.md` |
+| A known risk or a risk that retired | `11_technical_risks.md` |
+| A new term, tool or abbreviation | `12_glossary.md` |
+
+Rules:
+
+- **Describe what exists.** No aspirational architecture: anything planned belongs in `ROADMAP.md` and `TODO.md`. Every structural claim names the file, script or flag that implements it.
+- **ADRs are append-only.** Never rewrite an accepted decision; supersede it with a new ADR that says what it replaces and why.
+- **Keep the combined document in sync.** `architecture.md` mirrors the section files; when a section changes, update the combined document too.
+- **Images** live in `Docs/Architecture/images/` and are referenced, not duplicated.
+- **Verify:** all Markdown must pass `prettier --check` (config in `.prettierrc`), and a command you quote must still run.
+
 ## Geographic & Art Pipeline
 
 1. Save a versioned OSM extract; document date, bounds, and source.

Art/blender/README.md

@@ -80,10 +80,7 @@ LD_LIBRARY_PATH="$B/blender/lib" "$B/blender/blender" -b --factory-startup \
 ```
 
 - `Road_Hollywood`: 8 120 verts, 7 812 faces, carriageway −10.5…+10.5 m, DEM elevations plus a 2 cm lift so it does not z-fight the terrain.
-- `Sidewalk_South` 4.0 m wide, `Sidewalk_North` 5.3 m wide. The kerb upstand is
-  **full at the road-side edge and tapers to zero at the building-side edge**, so
-  the walk surface meets the terrain flush (before `0.1.1` the outer lip stood the
-  full kerb height above the DEM — a 15.8 cm ledge).
+- `Sidewalk_South` 4.0 m wide, `Sidewalk_North` 5.3 m wide. The kerb upstand is **full at the road-side edge and tapers to zero at the building-side edge**, so the walk surface meets the terrain flush (before `0.1.1` the outer lip stood the full kerb height above the DEM — a 15.8 cm ledge).
 - `Kerb_South`, `Kerb_North`: vertical faces, mostly **0.13 m** — the 0.15 m assumption minus nothing on the road side — and flushed to 0 within ±2.5 m of each signalised crossing with a 1.5 m blend. Measured from the built mesh: 256 steps at 0.13 m, 15 flush, a few in transition.
 
 Crown check on the built mesh at mid-block: gutter −10.5 m → +0.99, −5 m → +1.38, centre → +1.52, +5 m → +1.58, +10.5 m → +1.52. The crown sits just north of the centreline, as the cross-sections said.
@@ -107,31 +104,19 @@ Objects are appended from the source files, not regenerated, and grouped into `S
 A downward raycast on a 1 m grid along both sidewalks and the designated crossing, ignoring blockout meshes so marquees and canopies overhead do not count as ground:
 
 | Route             | Samples | Holes | Z range       |        Worst step |
-| ----------------- | ------: | ----: | ------------- | ---------: |
+| ----------------- | ------: | ----: | ------------- | ----------------: |
 | South sidewalk    |     279 |     0 | −0.48 … +3.06 |   13.4 cm (s=198) |
 | North sidewalk    |     279 |     0 | +0.06 … +3.76 |     6.9 cm (s=33) |
 | Crossing at 130 m |      26 |     0 | +1.14 … +1.80 | 9.0 cm (off −8.5) |
 
-At `--sample 0.25` the same routes measure 11.6 cm / 8.0 cm / 3.4 cm. The
-pre-check now prints the grade and the **location** of the worst step, and its
-coverage no longer shrinks with `--sample`.
+At `--sample 0.25` the same routes measure 11.6 cm / 8.0 cm / 3.4 cm. The pre-check now prints the grade and the **location** of the worst step, and its coverage no longer shrinks with `--sample`.
 
 No holes anywhere, so nothing drops the player on either side. The two flagged steps:
 
-- ~~15.8 cm at s≈207, the sidewalk's outer edge~~ — **fixed in `0.1.1`**: the
-  sidewalk upstand now tapers to zero at the building side, so the outer edge is
-  flush with the terrain (north route 15.1 → 6.9 cm).
-- ~~10–13 cm steps at the crossings, ~10 % ramp over 1.5 m~~ — **fixed in `0.1.1`**:
-  the ramp run is now derived from a target grade (`--max-ramp-grade`, default 8 %),
-  giving 1.63 m instead of the fixed 1.5 m (8.7 %). Measured at 0.25 m sampling the
-  crossing now steps 3.4 cm (~1.4 % of the route) at the kerb line.
+- ~~15.8 cm at s≈207, the sidewalk's outer edge~~ — **fixed in `0.1.1`**: the sidewalk upstand now tapers to zero at the building side, so the outer edge is flush with the terrain (north route 15.1 → 6.9 cm).
+- ~~10–13 cm steps at the crossings, ~10 % ramp over 1.5 m~~ — **fixed in `0.1.1`**: the ramp run is now derived from a target grade (`--max-ramp-grade`, default 8 %), giving 1.63 m instead of the fixed 1.5 m (8.7 %). Measured at 0.25 m sampling the crossing now steps 3.4 cm (~1.4 % of the route) at the kerb line.
 
-**Remaining finding (not a crossing, not the outer edge):** the south route still
-measures a **13.4 cm step at s≈198 m** (11.6 cm at 0.25 m sampling) and the north
-route 8.0 cm at s≈251 m. Neither is at a crossing and neither is the outer lip, so
-this is a local discontinuity in the sidewalk strip — most likely the DEM sampling
-or a centreline vertex near the block ends. Tracked under the `0.1.1` "audit any
-collision gaps" item rather than left undocumented.
+**Remaining finding (not a crossing, not the outer edge):** the south route still measures a **13.4 cm step at s≈198 m** (11.6 cm at 0.25 m sampling) and the north route 8.0 cm at s≈251 m. Neither is at a crossing and neither is the outer lip, so this is a local discontinuity in the sidewalk strip — most likely the DEM sampling or a centreline vertex near the block ends. Tracked under the `0.1.1` "audit any collision gaps" item rather than left undocumented.
 
 This is a pre-check, not the `0.1.0` release check: the release check is traversal in the engine.
 
@@ -146,13 +131,15 @@ Blender works in metres, and the imported meshes match the OSM geometry, so the
 | Building | Blender dimensions | OSM way outline | Height source |
 | --- | --- | --- | --- |
 | El Capitan Entertainment Centre | 25.72 × 54.47 × 14.50 m | 25.75 × 54.88 m | `height` tag 14.5 |
-| El Capitan Theatre | 38.66 × 54.46 × 20.96 m | 38.59 × 54.87 m | `building:levels=6` × 3.2 m, plus roof |
+| El Capitan Theatre | 38.66 × 54.46 × 20.55 m | 38.59 × 54.87 m | `building:levels=6` × **3.1 m**, plus ~1.9 m roof |
 | Madame Tussaud's | 42.48 × 56.77 × 15.90 m | 42.0 m frontage | `height` tag 15.9 |
 | TCL Chinese Theatre | 43.78 × 75.90 × 18.10 m | 44.0 m frontage | `height` tag 18.1 |
 
 Widths agree to a few centimetres; depths differ by up to 0.4 m because Blosm assembles **multipolygon relations**, not the raw way I measured. Placement after the frame correction agrees with the UTM control points to 0.1–0.5 m per building — the residual is relation assembly and Blosm's edge straightening, not projection.
 
-Buildings **without** a `height` tag get levels × 3.2 m, which is a placeholder, not evidence. Every such height is a modelling decision to be replaced from the reference photography.
+Buildings **without** a `height` tag get levels × **3.1 m**. The storey height was 3.2 m until 2026-11-09, when a cross-check of every block building against Mapbox's building data (`Geo/tools/mapbox_buildings.py`) showed our figure running 0.6 m high per six levels — i.e. 3.1 m per level — and that calibration was adopted. The few buildings where Mapbox disagreed with a pure `levels × 3.1 m` fallback carry an explicit override in `Geo/tools/block_height_report.py::HEIGHT_OVERRIDES`.
+
+Blosm adds roof mass on top of `levels × levelHeight`: the two `levels`-derived frontage buildings both land ~1.9 m above their table height (6922 39.1 m against 37.2 m, El Capitan Theatre 20.5 m against 18.6 m). That offset is the roof, not a height error — the table records the tagged height, the mesh records the storey plus its roof.
 
 ## Relation completeness
 

Art/blender/blockout/blosm_blockout.py

@@ -40,7 +40,9 @@ def parse_args():
     ap.add_argument("--osm", required=True, help="local .osm file to import")
     ap.add_argument("--bounds", required=True, help="south,west,north,east in WGS84 degrees")
     ap.add_argument("--out", required=True, help="output .blend path")
-    ap.add_argument("--level-height", type=float, default=3.2, help="metres per building level")
+    # 3.1 m, not 3.2: calibrated against Mapbox building data on 2026-11-09
+    # (see Geo/tools/mapbox_buildings.py and Geo/tools/block_height_report.py).
+    ap.add_argument("--level-height", type=float, default=3.1, help="metres per building level")
     ap.add_argument("--origin", default=None,
                     help="lat,lon to use as the Blender origin (project origin). Default: Blosm centres on the extract")
     ap.add_argument("--no-subdivide", action="store_true", help="skip OSM area subdivision")

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

@@ -33,7 +33,7 @@
       "dims_m": [
         0.95,
         0.95,
-        7.45
+        8.25
       ],
       "evidence": "6 columns at 4.96 m centres (sibling notes x measured frontage)"
     },
@@ -60,7 +60,7 @@
       "dims_m": [
         25.75,
         1.5,
-        3.4
+        3.0
       ],
       "evidence": "assumption: entablature depth"
     },
@@ -69,7 +69,7 @@
       "dims_m": [
         25.75,
         1.2,
-        2.2
+        1.8
       ],
       "evidence": "assumption: parapet carries the motto band"
     },

Docs/Architecture/05_building_block_view.md

@@ -60,8 +60,11 @@ Python scripts in `Tools/` drive the content pipeline:
 | `ue_create_input_assets` | Enhanced Input actions + mapping context |
 | `render_screenshots.sh` | Screenshot capture pipeline |
 | `judge_screenshot.py` | Vision-model pre-check (optional) |
+| `input_emulation.py`, `input_test.py` | OS-level virtual keyboard/mouse injection for input verification |
+| `Tools/tests/` | Stdlib `unittest` tests for the pure parts of the tools (`requirements-tools.txt`) |
+| `Geo/tools/mapbox_buildings.py` | Second height source: Mapbox `mapbox-streets-v8` building data vs our OSM heights |
 
-Source data: `Art/blender/` (`.blend` files), `Geo/` (OSM extracts, DEM, verification docs).
+Source data: `Art/blender/` (`.blend` files), `Geo/` (OSM extracts, DEM, verification docs). Tool rules (one script one job, result files for commandlets, clean worktree for generators, documented inventory, tests for the pure parts) are in [`AGENTS.md`](../../AGENTS.md#python-and-shell-tooling).
 
 ### QA & Review
 

Docs/Architecture/architecture.md

@@ -199,6 +199,9 @@ Python scripts in `Tools/` drive the content pipeline:
 | `ue_create_input_assets` | Enhanced Input actions + mapping context |
 | `render_screenshots.sh` | Screenshot capture pipeline |
 | `judge_screenshot.py` | Vision-model pre-check (optional) |
+| `input_emulation.py`, `input_test.py` | OS-level virtual keyboard/mouse injection for input verification |
+| `Tools/tests/` | Stdlib `unittest` tests for the pure parts of the tools (`requirements-tools.txt`) |
+| `Geo/tools/mapbox_buildings.py` | Second height source: Mapbox `mapbox-streets-v8` building data vs our OSM heights |
 
 Source data: `Art/blender/` (`.blend` files), `Geo/` (OSM extracts, DEM, verification docs).
 

Geo/README.md

@@ -27,6 +27,7 @@ Tools that build 3D content from these sources live next to their output in `Art
 | `elevation_probe.py` | Samples 3DEP for relief and records the baseline for the release checks |
 | `dem_stats.py` | Stdlib reader for the tiled GeoTIFF the 3DEP service returns; GDAL does not run on this host |
 | `asset_metadata.py` | Writes and audits `<asset>.geo.json` sidecars: position, provenance, conversion |
+| `mapbox_buildings.py` | Cross-checks every building's height against Mapbox `mapbox-streets-v8` building data (Tilequery per centroid), merging our OSM height + source with theirs and flagging matches, close, disagreements, non-building volumes. Needs `MAPBOX_ACCESS_TOKEN` in `.env`; caches responses under `Geo/raw/mapbox-cache/`, and **both the cache and its report are gitignored** (Mapbox terms restrict redistribution) |
 
 ## Unit boundary
 

Geo/tools/block_height_report.py

@@ -4,9 +4,21 @@
 Usage:
     Geo/tools/block_height_report.py Geo/raw/osm-api-map-2026-11-06.osm
 
-`height` and `building:levels` are the only height evidence OSM carries. Where
-neither exists, Blosm falls back to `defaultLevels * levelHeight`, which is a
-placeholder: the demo renders a constant-height block instead of a real skyline.
+Height evidence, in priority order:
+
+1. the OSM `height` tag (a direct measurement);
+2. an explicit override in `HEIGHT_OVERRIDES` (currently Mapbox-derived — see below);
+3. `building:levels` x `LEVEL_HEIGHT`;
+4. a flagged placeholder guess.
+
+`LEVEL_HEIGHT` is 3.1 m, not the 3.2 m first assumed: cross-checking every block
+building against Mapbox's building data (`Geo/tools/mapbox_buildings.py`) showed
+our `levels x 3.2 m` figure running 0.6 m high per six levels, i.e. 3.1 m per
+level. That calibration was adopted on 2026-11-09.
+
+`HEIGHT_OVERRIDES` carries the few buildings where Mapbox disagrees with a guess;
+each entry records why, so the number is not orphaned from its evidence.
+
 This tool lists every building in the demo bounds with its height source, so the
 substitutions are visible and measurable rather than buried in the model.
 
@@ -19,7 +31,45 @@ import sys
 
 import osm_common as oc
 
-LEVEL_HEIGHT = 3.2
+LEVEL_HEIGHT = 3.1
+
+# Per-way height overrides, applied after the OSM height tag and before the
+# levels/guess derivation. Keep `reason` short but specific: a height without its
+# evidence is a guess wearing a costume.
+HEIGHT_OVERRIDES = {
+    # Rear outbuildings tagged only `building=yes`/`apartments`; the two-level
+    # fallback rendered them as 6.4 m blocks. Mapbox's building layer gives 3.0 m
+    # for the same footprints (single storey plus parapet), adopted 2026-11-09.
+    1490910971: (3.0, "Mapbox building layer: 3.0 m (single storey)"),
+    1492058875: (3.0, "Mapbox building layer: 3.0 m (single storey)"),
+    1492747608: (3.0, "Mapbox building layer: 3.0 m (single storey)"),
+}
+
+
+def classify_height(tags, level_height=LEVEL_HEIGHT, way_id=None):
+    """Return (height_m, source) for one OSM way's tags.
+
+    Extracted from `main()` so the classification is testable: the roof/shelter
+    rule and the "height tag beats levels beats guess" order are the parts that
+    actually decide what the blockout should render.
+    """
+    # Not building volumes: elevated roof/canopy structures and transit shelters.
+    # Found by cross-checking against Mapbox's building data
+    # (Geo/tools/mapbox_buildings.py), which returns roof/canopy/shelter for the
+    # same footprints instead of a storey count.
+    building = tags.get("building")
+    if building in ("roof", "canopy") or tags.get("amenity") == "shelter":
+        kind = building if building in ("roof", "canopy") else "shelter"
+        return 0.0, f"not a building volume ({kind})"
+    if tags.get("height"):
+        return float(tags["height"]), "height tag"
+    if way_id is not None and int(way_id) in HEIGHT_OVERRIDES:
+        height, reason = HEIGHT_OVERRIDES[int(way_id)]
+        return height, f"override: {reason}"
+    if tags.get("building:levels"):
+        return (float(tags["building:levels"]) * level_height,
+                f"levels x {level_height} m")
+    return 2 * level_height, f"GUESS: default 2 levels x {level_height} m"
 
 
 def main():
@@ -43,14 +93,7 @@ def main():
         pts = oc.way_points(nodes, refs)
         if not pts or not in_block(pts):
             continue
-        tag_height = tags.get("height")
-        levels = tags.get("building:levels")
-        if tag_height:
-            height, source = float(tag_height), "height tag"
-        elif levels:
-            height, source = float(levels) * LEVEL_HEIGHT, f"levels x {LEVEL_HEIGHT} m"
-        else:
-            height, source = 2 * LEVEL_HEIGHT, f"GUESS: default 2 levels x {LEVEL_HEIGHT} m"
+        height, source = classify_height(tags, way_id=wid)
         nearest = min(oc.project(p, line, lat0, lon0, lengths)[0] for p in pts)
         side = "S" if oc.project(pts[0], line, lat0, lon0, lengths)[2] < 0 else "N"
         rows.append((side, nearest, wid, tags.get("name", "") or tags.get("addr:housenumber", ""),
@@ -60,7 +103,8 @@ def main():
     guessed = [r for r in rows if r[5].startswith("GUESS")]
     print(f"{len(rows)} buildings in the block, {len(guessed)} with a guessed height\n")
     for side, setback, wid, name, height, source in rows:
-        flag = "  <-- guessed" if source.startswith("GUESS") else ""
+        flag = ("  <-- guessed" if source.startswith("GUESS")
+                else ("  <-- not a building volume" if source.startswith("not a building") else ""))
         print(f"{side} way {wid:>10}  setback {setback:5.1f} m  height {height:5.1f} m  "
               f"({source:26})  {name[:34]}{flag}")
 

Geo/tools/mapbox_buildings.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""Cross-check block building heights against Mapbox's building data.
+
+Mapbox publishes building footprints with ``height`` / ``min_height`` /
+``type`` attributes in the ``mapbox-streets-v8`` tileset. They come from
+different source data than our OSM extract, so comparing the two is a cheap way
+to find buildings where our height is wrong or missing — the ``0.1.2`` finding
+that three "guessed" volumes were actually a roof, a roof and a bus shelter is
+exactly the class of problem this tool hunts for.
+
+Usage
+-----
+    # token from the environment or the ignored .env file
+    python3 Geo/tools/mapbox_buildings.py \
+        --osm Geo/raw/osm-api-map-2026-11-06.osm \
+        --out Geo/verification/2026-11-09-mapbox-buildings.md
+
+    # show only disagreements and unverifiable buildings
+    python3 Geo/tools/mapbox_buildings.py --only-diffs
+
+Every Tilequery response is cached under ``Geo/raw/mapbox-cache/`` so a re-run
+costs nothing and the report is reproducible. The cache is gitignored along with
+``Geo/raw/``.
+
+Design notes
+------------
+* Standard library only (``urllib``), like the rest of ``Geo/tools``.
+* One request per building, spaced by ``--delay`` (default 1.2 s) — Mapbox bills
+  per request and rate-limits bursts.
+* The report is a *measurement*: it prints both figures and the delta, never a
+  single verdict, so a human can decide which source to trust for a given
+  building.
+* A Tilequery hit is only accepted as "this building" when the matched polygon
+  contains or nearly contains the queried point (``distance`` ≤ ``--max-distance``).
+
+Licensing / data handling
+-------------------------
+Mapbox terms restrict persisting and redistributing their data, so **neither the
+cache nor the generated report is committed** (`.gitignore` covers
+`Geo/raw/mapbox-cache/` and `Geo/verification/*mapbox*`). They are local working
+material: re-run the tool rather than sharing the output. The token is read from
+the environment or the ignored `.env` and is never written to the cache, the
+report or the JSON.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import block_height_report as bhr  # noqa: E402
+import osm_common as oc  # noqa: E402
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+CACHE_DIR = os.path.join(ROOT, "Geo", "raw", "mapbox-cache")
+TILESET = "mapbox.mapbox-streets-v8"
+LAYER = "building"
+API = "https://api.mapbox.com/v4"
+
+
+def load_token(explicit: str | None = None) -> str:
+    """Token from --token, the environment, or the ignored .env file."""
+    if explicit:
+        return explicit.strip()
+    token = os.environ.get("MAPBOX_ACCESS_TOKEN")
+    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("MAPBOX_ACCESS_TOKEN="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit(
+        "no Mapbox token: pass --token, set MAPBOX_ACCESS_TOKEN, or add it to .env")
+
+
+def centroid_lat_lon(points: list[tuple[float, float]]) -> tuple[float, float]:
+    """Centroid of a ring of (lat, lon) points, as (lat, lon)."""
+    lat = sum(p[0] for p in points) / len(points)
+    lon = sum(p[1] for p in points) / len(points)
+    return lat, lon
+
+
+def cache_path(lat: float, lon: float, radius: int) -> str:
+    return os.path.join(CACHE_DIR, f"{lat:.6f}_{lon:.6f}_r{radius}.json")
+
+
+def tilequery(lat: float, lon: float, token: str, radius: int,
+              delay: float, use_cache: bool = True) -> tuple[dict, bool]:
+    """Tilequery one point. Returns (payload, from_cache)."""
+    path = cache_path(lat, lon, radius)
+    if use_cache and os.path.exists(path):
+        with open(path, encoding="utf-8") as handle:
+            return json.load(handle), True
+
+    query = urllib.parse.urlencode({
+        "radius": radius, "layers": LAYER, "limit": 10, "access_token": token,
+    })
+    url = f"{API}/{TILESET}/tilequery/{lon:.6f},{lat:.6f}.json?{query}"
+    request = urllib.request.Request(url, headers={"User-Agent": "gig-line-geo/1.0"})
+    payload = None
+    for attempt in range(4):
+        try:
+            with urllib.request.urlopen(request, timeout=30) as response:
+                payload = json.load(response)
+            break
+        except urllib.error.HTTPError as exc:
+            if exc.code == 429 or exc.code >= 500:
+                wait = delay * (2 ** attempt)
+                sys.stderr.write(f"  HTTP {exc.code}; retrying in {wait:.1f}s\n")
+                time.sleep(wait)
+                continue
+            raise
+        except urllib.error.URLError as exc:
+            sys.stderr.write(f"  network error ({exc.reason}); retrying\n")
+            time.sleep(delay * (2 ** attempt))
+    if payload is None:
+        raise SystemExit(f"tilequery failed for {lat:.6f},{lon:.6f}")
+    if token in json.dumps(payload):
+        raise SystemExit("refusing to cache a response that contains the token")
+
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle)
+    time.sleep(delay)  # only sleep on a real request, never on a cache hit
+    return payload, False
+
+
+def nearest_building(payload: dict, max_distance: float) -> dict | None:
+    """The closest building feature within `max_distance` metres, or None."""
+    best = None
+    for feature in payload.get("features", []):
+        props = feature.get("properties", {})
+        if props.get("tilequery", {}).get("layer") != LAYER:
+            continue
+        distance = props.get("tilequery", {}).get("distance")
+        if distance is None or distance > max_distance:
+            continue
+        if best is None or distance < best[0]:
+            best = (distance, props)
+    return None if best is None else best[1]
+
+
+def compare(ours: float, ours_source: str, theirs: float | None) -> tuple[str, float | None]:
+    """Classify the agreement between our height and Mapbox's.
+
+    Returns (verdict, delta_m). Verdicts are deliberately blunt so the report can
+    be scanned: "match", "close", "disagree", "mapbox-only", "ours-only".
+    """
+    ours_is_volume = not ours_source.startswith("not a building")
+    if not ours_is_volume:
+        return "non-building", None
+    if theirs is None:
+        return "ours-only", None
+    if ours <= 0.0:
+        return "mapbox-only", theirs
+    delta = theirs - ours
+    if abs(delta) <= 0.5:
+        return "match", delta
+    if abs(delta) <= 2.0:
+        return "close", delta
+    return "disagree", delta
+
+
+def build_rows(nodes, ways, token, radius, max_distance, delay) -> list[dict]:
+    rows = []
+    for wid, tags, refs in ways:
+        if "building" not in tags:
+            continue
+        points = oc.way_points(nodes, refs)
+        if not points:
+            continue
+        lat, lon = centroid_lat_lon(points)
+        payload, cached = tilequery(lat, lon, token, radius, delay)
+        feature = nearest_building(payload, max_distance)
+        ours_height, ours_source = bhr.classify_height(tags, way_id=wid)
+        theirs = None if feature is None else feature.get("height")
+        verdict, delta = compare(ours_height, ours_source, theirs)
+        rows.append({
+            "way": wid,
+            "name": tags.get("name") or tags.get("addr:housenumber") or "",
+            "kind": tags.get("building"),
+            "osm_height_m": round(ours_height, 2) if ours_height else 0.0,
+            "osm_source": ours_source,
+            "mapbox_height_m": None if theirs is None else round(float(theirs), 2),
+            "mapbox_min_height_m": None if feature is None else feature.get("min_height"),
+            "mapbox_type": None if feature is None else feature.get("type"),
+            "mapbox_distance_m": None if feature is None
+            else round(feature.get("tilequery", {}).get("distance", 0.0), 1),
+            "verdict": verdict,
+            "delta_m": None if delta is None else round(delta, 2),
+            "cached": cached,
+            "lat": round(lat, 6),
+            "lon": round(lon, 6),
+        })
+    return rows
+
+
+def render_markdown(rows: list[dict], args) -> str:
+    order = {"disagree": 0, "mapbox-only": 1, "ours-only": 2,
+             "non-building": 3, "close": 4, "match": 5}
+    rows = sorted(rows, key=lambda r: (order.get(r["verdict"], 9),
+                                       -abs(r["delta_m"] or 0)))
+    counts = {}
+    for row in rows:
+        counts[row["verdict"]] = counts.get(row["verdict"], 0) + 1
+
+    lines = [
+        "# Block buildings — OSM vs Mapbox",
+        "",
+        "Generated by `Geo/tools/mapbox_buildings.py`; re-run it to reproduce.",
+        "Mapbox data: tileset `mapbox-streets-v8`, layer `building`, Tilequery",
+        f"at each building centroid (radius {args.radius} m, accept ≤ "
+        f"{args.max_distance} m). OSM heights come from the tagged extract, via the",
+        "same classification used for the blockout (tag > levels > guess; roof and",
+        "shelter are not building volumes).",
+        "",
+        f"Verdicts: {', '.join(f'{k} {v}' for k, v in sorted(counts.items()))}.",
+        "",
+        "| Verdict | Δ | Building | OSM | OSM source | Mapbox | Mapbox type | dist |",
+        "| --- | ---: | --- | ---: | --- | ---: | --- | ---: |",
+    ]
+    for row in rows:
+        osm = f"{row['osm_height_m']:.1f} m"
+        mb = "—" if row["mapbox_height_m"] is None else f"{row['mapbox_height_m']:.1f} m"
+        delta = "—" if row["delta_m"] is None else f"{row['delta_m']:+.1f} m"
+        dist = "—" if row["mapbox_distance_m"] is None else f"{row['mapbox_distance_m']:.0f} m"
+        name = row["name"] or f"way {row['way']}"
+        lines.append(
+            f"| {row['verdict']} | {delta} | {name} | {osm} | {row['osm_source']} | "
+            f"{mb} | {row['mapbox_type'] or '—'} | {dist} |")
+    lines += [
+        "",
+        "## How to read this",
+        "",
+        "- **disagree** — the two sources differ by more than 2 m. One of them is",
+        "  wrong; check the reference photography before changing the model.",
+        "- **mapbox-only** — Mapbox knows a height we do not (usually a building",
+        "  with no OSM `height`/`building:levels`).",
+        "- **ours-only** — Mapbox returns no building within the accept distance;",
+        "  the footprint may be missing from its tileset, or the centroid may fall",
+        "  outside its polygon.",
+        "- **non-building** — our classification says roof/shelter; excluded from",
+        "  height comparison on purpose.",
+        "",
+        "Neither source is authoritative: OSM is community-tagged, Mapbox is a",
+        "derived commercial dataset. Treat a disagreement as a reason to look at",
+        "the photographs, not as an automatic correction.",
+        "",
+    ]
+    if args.only_diffs:
+        lines.insert(0, "> Filtered: only disagreements and unverifiable buildings.\n")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--osm", default="Geo/raw/osm-api-map-2026-11-06.osm")
+    ap.add_argument("--out", help="Markdown report path; omit to print to stdout")
+    ap.add_argument("--json", help="Also write the merged rows as JSON here")
+    ap.add_argument("--token", help="Mapbox access token (default: env/.env)")
+    ap.add_argument("--radius", type=int, default=25, help="Tilequery radius, metres")
+    ap.add_argument("--max-distance", type=float, default=8.0,
+                    help="accept a hit only within this distance of the centroid")
+    ap.add_argument("--delay", type=float, default=1.2, help="seconds between requests")
+    ap.add_argument("--only-diffs", action="store_true",
+                    help="report only disagreements / unverifiable buildings")
+    ap.add_argument("--no-cache", action="store_true", help="ignore the tilequery cache")
+    args = ap.parse_args()
+
+    token = load_token(args.token)
+    nodes, ways = oc.load(args.osm)
+    rows = build_rows(nodes, ways, token, args.radius, args.max_distance, args.delay)
+    if args.no_cache:
+        for row in rows:
+            row["cached"] = False
+    if args.only_diffs:
+        keep = {"disagree", "mapbox-only", "ours-only", "non-building"}
+        rows = [r for r in rows if r["verdict"] in keep]
+
+    markdown = render_markdown(rows, args)
+    if args.out:
+        os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
+        with open(args.out, "w", encoding="utf-8") as handle:
+            handle.write(markdown + "\n")
+        print(f"wrote {args.out} ({len(rows)} buildings)")
+    else:
+        print(markdown)
+
+    if args.json:
+        payload = {
+            "generated_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "osm": args.osm,
+            "mapbox": {"tileset": TILESET, "layer": LAYER,
+                       "radius_m": args.radius, "max_distance_m": args.max_distance},
+            "buildings": rows,
+        }
+        with open(args.json, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, indent=2)
+        print(f"wrote {args.json}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

MEMORY.md

@@ -359,3 +359,84 @@ Scope: facts and traps that cost time to establish. Planned work lives in [TODO.
   45 cm MaxStepHeight, so not blocking.
 - Kerb height finalised at 0.15 m modelled / 0.13 m built (6 in LA standard; DEM
   and photos can't resolve finer).
+
+## 2026-11-09 — Mapbox building data as a second height source
+
+- `Geo/tools/mapbox_buildings.py` (new, stdlib `urllib`) Tilequeries
+  `mapbox.mapbox-streets-v8` layer `building` at every building centroid in the
+  extract and merges the answer with our OSM height + source. Token comes from
+  `MAPBOX_ACCESS_TOKEN` in the ignored `.env`; responses cache to
+  `Geo/raw/mapbox-cache/`.
+- **Mapbox terms restrict persisting/redistributing their data**, so `.gitignore`
+  now covers `/Geo/raw/mapbox-cache/` and `/Geo/verification/*mapbox*`. The tool
+  also refuses to cache a response that contains the token.
+- **First run (72 buildings): 58 match, 5 close, 3 disagree, 6 non-building.**
+  - It independently classifies our roof/canopy/shelter volumes as `roof`/
+    `shelter` — corroborating the `0.1.2` finding that they are not buildings.
+  - Remaining disagreements are untyped `building=yes`/`apartments` rear
+    structures where our fallback guess (2 × 3.2 m = 6.4 m) meets Mapbox's 3.0 m.
+  - Every "close" case is a `building:levels × 3.2 m` building where Mapbox is
+    **0.6 m lower per 6 levels** → Mapbox implies **3.1 m per level**, not 3.2.
+    Worth revisiting `LEVEL_HEIGHT` if a measured storey height ever lands.
+  - Its query API surface: `height`, `min_height`, `type`, `extrude` per polygon.
+
+## 2026-11-09 — Mapbox calibration adopted into the blockout
+
+- Owner decision: adopt Mapbox. Applied:
+  - `LEVEL_HEIGHT` 3.2 → **3.1 m** in `Geo/tools/block_height_report.py`, and the
+    Blosm `--level-height` default in `Art/blender/blockout/blosm_blockout.py`.
+  - `HEIGHT_OVERRIDES` in block_height_report: ways 1490910971, 1492058875,
+    1492747608 → 3.0 m (Mapbox single-storey; the 2-level guess gave 6.4 m).
+  - `classify_height(tags, level_height, way_id)` now takes the way id so
+    overrides apply; `mapbox_buildings.py` passes it, so the cross-check agrees
+    with the height table.
+- Re-running the cross-check: **66 match, 6 non-building, 0 close/disagree**.
+- Geometry: blockout regenerated at 3.1 (object names preserved — the frontage
+  exporter maps `element.020`/`element`/`element.019`/named buildings, all still
+  present, 6/6 exported), frontage re-imported, DemoMap rebuilt, packaged build
+  `-qaselftest` all PASS.
+- **Blosm adds roof mass** on top of `levels × levelHeight`: 6922 39.1 m vs table
+  37.2, El Capitan Theatre 20.5 m vs 18.6 — both ~+1.9 m. That is a roof, not a
+  height error; the table is the tagged height, the mesh is storey + roof.
+- Gotcha: regenerating the blockout is safe for names, but any future change to
+  the import must re-verify the 6/6 frontage export and the `element.*` mapping.
+
+## 2026-11-09 — hero colonnade proportion fixed (47.6 % → 53.1 %)
+
+- The hero's colonnade (columns 2.00–7.95 + capitals 7.95–8.90) was 6.90 m of the
+  14.50 m elevation = **47.6 %**, below the photographed 50–60 %, because the
+  entablature (3.40 m) and parapet (2.20 m) used 5.60 m of the height.
+- Thinned ENTABLATURE_H 3.40 → 3.00 and PARAPET_H 2.20 → 1.80 in
+  `Tools/hero_facade_build.py`; the colonnade grows to **7.70 m = 53.1 %** while the
+  envelope, motto band and medallions keep their relationships (all positioned
+  relative to those two constants).
+- **Gotcha (cost a bad build):** `hero_facade_build.py` takes `--out` for the
+  **FBX** and `--save-blend` for the `.blend`. Passing `--out <file>.blend` writes
+  FBX bytes over the blend and Blender then reports "File format is not supported".
+  Correct invocation: `--out /tmp/gigline/hero-facade.fbx --save-blend Art/...blend
+  --report Art/...json`.
+- 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).

Screenshots/README.md

@@ -14,26 +14,30 @@ Rebuilds `Game/GigLine/Content/Test/ReviewMap.umap` from current content, runs t
 
 ## Shot list
 
-All shots ☑ approved 2026-11-07, including the block frontage pass that added the neighbouring buildings and corrected the hero and north-building placement.
+**Status: whole set ☑ approved 2026-11-09** (owner review of PR #27). Every shot was re-rendered from current `main` content after the building-height calibration was adopted (`v0.1.2`): Mapbox-derived **3.1 m per level** (`Geo/tools/block_height_report.py`), explicit overrides for three rear outbuildings, and the regenerated blockout and frontage that follow — 6922 is now 39.1 m (was 42.1 m) and the El Capitan Theatre 20.5 m (was 20.0 m).
 
-**2026-11-08 — regenerated set (v0.1.1 geometry).** Re-rendered again after the `0.1.1` street change (sidewalk upstand tapered to the building edge, crossing ramps graded to ≤8 %). Re-rendered via `Tools/render_screenshots.sh` after the placement release check. The `demo-north-buildings` camera was re-pointed (it previously sat 9.5 km west and framed 85 % sky); that shot now shows both north buildings, and all maps carry the re-staged shot cameras. **Approved 2026-11-08** (owner review of the regenerated set).
+| Round | What changed |
+| --- | --- |
+| 2026-11-07 | First approved set; block frontage pass corrected hero and north-building placement |
+| 2026-11-08 | Re-rendered after `0.1.1` street geometry (sidewalk upstand flush at the building edge, crossing ramps graded ≤ 8 %); `demo-north-buildings` camera re-pointed (was 9.5 km west, 85 % sky) |
+| 2026-11-09 | Re-rendered after the `0.1.2` building-height calibration (3.1 m per level). 12 of 14 PNGs changed; `review-demo-spawn-view` and `review-demo-street-level` are byte-identical to the `0.1.1` round, so the height change reads mostly on the frontage silhouettes |
 
-| # | File | Preview | Map | View | What it shows |
-| --- | --- | --- | --- | --- | --- |
-| 1 | `review-overview.png` | [<img src="review-overview.png" alt="overview" width="180">](review-overview.png) | Review | 7 m up, NE | Whole review layout: character + both cubes on the floor |
-| 2 | `review-character.png` | [<img src="review-character.png" alt="character" width="180">](review-character.png) | Review | eye height, south | MPFB mannequin, idle pose + warm skin; feet meet the plane |
-| 3 | `review-scale-cubes.png` | [<img src="review-scale-cubes.png" alt="scale cubes" width="180">](review-scale-cubes.png) | Review | south | Floating vs grounded cube: cast vs contact shadow |
-| 4 | `review-player-placement.png` | [<img src="review-player-placement.png" alt="player placement" width="180">](review-player-placement.png) | Review | spawn | The `AGigLineCharacter` pawn, capsule height and landing |
-| 5 | `review-npc-prefab.png` | [<img src="review-npc-prefab.png" alt="npc prefab" width="180">](review-npc-prefab.png) | Review | mid, west | The `AGigLineNPCPerson` prefab: collision capsule + visible MPFB body, feet on Z 0 |
-| 6 | `review-ground-contact.png` | [<img src="review-ground-contact.png" alt="ground contact" width="180">](review-ground-contact.png) | Review | knee height, feet | Floating/sinking character is obvious here |
-| 7 | `review-shadow-compare.png` | [<img src="review-shadow-compare.png" alt="shadow compare" width="180">](review-shadow-compare.png) | Review | low angle | Detached (floating) vs touching (grounded) shadows |
-| 8 | `review-hero-portals.png` | [<img src="review-hero-portals.png" alt="hero portals" width="180">](review-hero-portals.png) | Review | 8 m, eye height | Three genuine 1.2 m portal recesses with flights and plinth |
-| 9 | `review-hero-facade-front.png` | [<img src="review-hero-facade-front.png" alt="hero facade front" width="180">](review-hero-facade-front.png) | Review | road side, straight-on | Hero façade elevation and column rhythm |
-| 10 | `review-hero-facade-oblique.png` | [<img src="review-hero-facade-oblique.png" alt="hero facade oblique" width="180">](review-hero-facade-oblique.png) | Review | north-west | Body depth and column line standing proud of the mass |
-| 11 | `demo/review-demo-spawn-view.png` | [<img src="demo/review-demo-spawn-view.png" alt="spawn view" width="180">](demo/review-demo-spawn-view.png) | Demo | north sidewalk | The whole block: hero façade between its neighbours, both sidewalks and the road |
-| 12 | `demo/review-demo-street-level.png` | [<img src="demo/review-demo-street-level.png" alt="street level" width="180">](demo/review-demo-street-level.png) | Demo | eye height, north side | The hero colonnade with the adjacent frontage buildings either side |
-| 13 | `demo/review-demo-crossing.png` | [<img src="demo/review-demo-crossing.png" alt="crossing" width="180">](demo/review-demo-crossing.png) | Demo | along the crosswalk | The designated mid-block crossing at s=130 m (UE X -14956): three zebra bars on the asphalt, with the south frontage and the hero colonnade behind |
-| 14 | `demo/review-demo-north-buildings.png` | [<img src="demo/review-demo-north-buildings.png" alt="north buildings" width="180">](demo/review-demo-north-buildings.png) | Demo | across the Blvd | North-side buildings (TCL, Tussaud's) seen from the south side across the road. **2026-11-08:** camera re-pointed to the buildings' mass centre (was 9.5 km west → 85% sky); now frames both north buildings. Flat surfaces = `0.1.4` façade scope. |
+| # | File | Preview | Map | View | What it shows | ☑ |
+| --- | --- | --- | --- | --- | --- | --- |
+| 1 | `review-overview.png` | [<img src="review-overview.png" alt="overview" width="180">](review-overview.png) | Review | 7 m up, NE | Whole review layout: character + both cubes on the floor | ☑ 2026-11-09 |
+| 2 | `review-character.png` | [<img src="review-character.png" alt="character" width="180">](review-character.png) | Review | eye height, south | MPFB mannequin, idle pose + warm skin; feet meet the plane | ☑ 2026-11-09 |
+| 3 | `review-scale-cubes.png` | [<img src="review-scale-cubes.png" alt="scale cubes" width="180">](review-scale-cubes.png) | Review | south | Floating vs grounded cube: cast vs contact shadow | ☑ 2026-11-09 |
+| 4 | `review-player-placement.png` | [<img src="review-player-placement.png" alt="player placement" width="180">](review-player-placement.png) | Review | spawn | The `AGigLineCharacter` pawn, capsule height and landing | ☑ 2026-11-09 |
+| 5 | `review-npc-prefab.png` | [<img src="review-npc-prefab.png" alt="npc prefab" width="180">](review-npc-prefab.png) | Review | mid, west | The `AGigLineNPCPerson` prefab: collision capsule + visible MPFB body, feet on Z 0 | ☑ 2026-11-09 |
+| 6 | `review-ground-contact.png` | [<img src="review-ground-contact.png" alt="ground contact" width="180">](review-ground-contact.png) | Review | knee height, feet | Floating/sinking character is obvious here | ☑ 2026-11-09 |
+| 7 | `review-shadow-compare.png` | [<img src="review-shadow-compare.png" alt="shadow compare" width="180">](review-shadow-compare.png) | Review | low angle | Detached (floating) vs touching (grounded) shadows | ☑ 2026-11-09 |
+| 8 | `review-hero-portals.png` | [<img src="review-hero-portals.png" alt="hero portals" width="180">](review-hero-portals.png) | Review | 8 m, eye height | Three genuine 1.2 m portal recesses with flights and plinth | ☑ 2026-11-09 |
+| 9 | `review-hero-facade-front.png` | [<img src="review-hero-facade-front.png" alt="hero facade front" width="180">](review-hero-facade-front.png) | Review | road side, straight-on | Hero façade elevation and column rhythm | ☑ 2026-11-09 |
+| 10 | `review-hero-facade-oblique.png` | [<img src="review-hero-facade-oblique.png" alt="hero facade oblique" width="180">](review-hero-facade-oblique.png) | Review | north-west | Body depth and column line standing proud of the mass | ☑ 2026-11-09 |
+| 11 | `demo/review-demo-spawn-view.png` | [<img src="demo/review-demo-spawn-view.png" alt="spawn view" width="180">](demo/review-demo-spawn-view.png) | Demo | north sidewalk | The whole block: hero façade between its neighbours, both sidewalks and the road | ☑ 2026-11-09 |
+| 12 | `demo/review-demo-street-level.png` | [<img src="demo/review-demo-street-level.png" alt="street level" width="180">](demo/review-demo-street-level.png) | Demo | eye height, north side | The hero colonnade with the adjacent frontage buildings either side | ☑ 2026-11-09 |
+| 13 | `demo/review-demo-crossing.png` | [<img src="demo/review-demo-crossing.png" alt="crossing" width="180">](demo/review-demo-crossing.png) | Demo | along the crosswalk | The designated mid-block crossing at s=130 m (UE X -14956): three zebra bars on the asphalt, with the south frontage and the hero colonnade behind | ☑ 2026-11-09 |
+| 14 | `demo/review-demo-north-buildings.png` | [<img src="demo/review-demo-north-buildings.png" alt="north buildings" width="180">](demo/review-demo-north-buildings.png) | Demo | across the Blvd | North-side buildings (TCL, Tussaud's) seen from the south side across the road. **2026-11-08:** camera re-pointed to the buildings' mass centre (was 9.5 km west → 85% sky); now frames both north buildings. Flat surfaces = `0.1.4` façade scope. | ☑ 2026-11-09 |
 
 ## Scene conventions
 
@@ -48,10 +52,12 @@ All shots ☑ approved 2026-11-07, including the block frontage pass that added
 - **Ground contact**: feet meet the plane with no gap and no shadow seam.
 - **Scale**: everything checks against the 1 m cubes.
 - **Façade rhythm**: six columns at 4.96 m across 25.75 m should read as the photographs in silhouette.
+- **Frontage heights (new in this round)**: 6922 and the El Capitan Theatre were re-cut to the 3.1 m storey height. Check they still read as the taller west end and the lower cinema respectively against `Art/reference/hollywood/el-capitan-theatre-blade-sign-day-wikimedia-2008-10.jpg`, and that the ordering of the six frontage buildings is unchanged.
 
 ## Known cosmetic issues
 
 - 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

@@ -13,12 +13,12 @@ Actionable task list for this project. This file is the single, central place fo
 
 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
+### Patch tasks - active - 01a1b26b-3c94-707f-9665-2f6b4a79b564 (branch `scale-facade-0.1.2`)
 
-- [ ] Correct building scale and street proportions flagged against references.
-- [ ] Refine hero façade details where reference photography shows discrepancies.
-- [ ] **Replace the placeholder heights.** Three of the fifteen block buildings carry no OSM height and render at a guessed 6.4 m (`Geo/tools/block_height_report.py`). Measure them off the photographs and correct the blockout.
-- [ ] 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.
+- [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. **Started 2026-11-09:** built `Tools/facade_detail_concepts.py`, which generates architectural detail plates from the local reference photographs with an image model (`--list` free, `--all` generates, sidecars + `-vN` no-overwrite, output gitignored). Eight studies generated locally under `Art/reference/facade-details/`: door recess, entrance, column order, entablature/cornice, parapet/motto, window rhythm, street wall, banner. **First fix from the measurement pass:** window panes were 1.44 m in front of the wall (ahead of the columns) and now sit on the wall plane behind the colonnade. Remaining: use the plates to correct the capital/base profiles and the medallion/cornice detail.
+- [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)

Tools/README.md

@@ -57,4 +57,28 @@ 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. |
-| `GigLine SIM` / `GigLine GROUND` log lines | Emitted every second by `AGigLineCharacter` (TEMP QA): position, fall state, movement mode, and what the ground probe hits underneath. Remove before release. |
+| `-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:`. |
+| `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 architectural detail plates from a local reference photograph with an image model (OpenRouter). `--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 |
+| --- | --- |
+| `input_emulation.py` | Pure-stdlib `ctypes`/`fcntl` driver that creates a virtual keyboard+mouse on `/dev/uinput`. The desktop treats it as real hardware, so it proves whether OS input actually reaches the game. Needs `/dev/uinput` writable (ACL on this host). |
+| `input_test.py` | Injects a scripted sequence into the focused window: `--sequence move:2,look:3,jump:1,reset:1,pause:1,click`. |
+
+## Tests
+
+```bash
+python3 -m pip install -r requirements-tools.txt
+python3 -m unittest discover -s Tools/tests -t Tools -p 'test_*.py'
+```
+
+Stdlib `unittest`, no Blender/Unreal process. See [`tests/README.md`](tests/README.md): test the pure parts (encoding, classification, maths, parsing); if logic is buried in `main()`, extract it into a function so it can be tested.

Tools/facade_detail_concepts.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""Generate architectural detail studies 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
+architectural detail plate — no crowd, no staging, straight-on, evenly lit — so
+the modelling pass has something to measure against instead of a tourist photo.
+
+    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 fixed source of geometry and "
+    "composition: keep the building's proportions, column rhythm, band heights, "
+    "signage placement and camera angle exactly as photographed. Only restage "
+    "lighting, weather, people and surface condition where the request asks for "
+    "it. Do not invent extra storeys, wings or ornaments that the photo does not "
+    "show."
+)
+
+# name -> (reference photo relative to Art/reference/, what the study must show)
+STUDIES: dict[str, tuple[str, str]] = {
+    "door-recess": (
+        "el-capitan-entrance/01-hollywood-el-capitan-entrance-detail.jpg",
+        "A clean architectural detail plate of exactly the subject in the "
+        "reference photograph. Render it as an even-daylight stone study: crisp "
+        "surface carving, readable depth of every recess and moulding, no people, "
+        "no signage or banners in front of it, no shop clutter, straight-on to the "
+        "subject.",
+    ),
+    "entrance-wide": (
+        "el-capitan-entrance/01-hollywood-el-capitan-entrance.jpg",
+        "A straight-on architectural study of the street entrance in the "
+        "reference photograph, the portal group centred and filling the frame, "
+        "threshold and pavement readable, no pedestrians or vehicles, even "
+        "overcast daylight, stone surface legible.",
+    ),
+    "column-order": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "A close architectural study of the column order visible in the "
+        "reference photograph: the base, shaft and capital read clearly, "
+        "neighbouring columns framing it. Straight-on, evenly lit, stone surface "
+        "and carving legible, no people or banners.",
+    ),
+    "entablature-cornice": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "An architectural detail study of the horizontal stone bands above the "
+        "columns in the reference photograph: every band edge and the projecting "
+        "cornice with its shadow line. The layered depth of the stone must be "
+        "readable, flat even light, no people.",
+    ),
+    "parapet-motto": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "An architectural study of the parapet above the colonnade in the "
+        "reference photograph: the inset panel, any round medallions beside it "
+        "and the coping at the top. Lettering on the panel is blocked out as "
+        "unreadable texture. Flat even light, no people.",
+    ),
+    "window-rhythm": (
+        "hollywood/el-capitan-facade-day-wikimedia-2009-10-27.jpg",
+        "An architectural study of the wall surface behind and between the "
+        "columns in the reference photograph: the opening or window rhythm and "
+        "the reveal depth. Straight-on, no people, no banners covering the wall.",
+    ),
+    "street-wall": (
+        "hollywood/el-capitan-theatre-blade-sign-day-wikimedia-2008-10.jpg",
+        "A clean street-wall study from the opposite pavement, as framed in the "
+        "reference photograph: the building line, the parapet heights of the "
+        "neighbouring buildings, the shopfront line and the pavement depth. No "
+        "crowd, even daylight.",
+    ),
+    "banner-detail": (
+        "el-capitan-premiere/02-premiere-of-spielberg-s-west-side-story---el-capitan---holly.jpg",
+        "An architectural study of the vertical banner in the reference "
+        "photograph: how it is fixed, its proportions against the column behind "
+        "it, and how it sits against the stone. Daylight, no crowd.",
+    ),
+}
+
+
+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/hero_facade_build.py

@@ -50,8 +50,12 @@ FRONTAGE_Y = 0.0        # front plane sits at the building line of the block fra
 PEDESTAL_H = 1.45       # column pedestal top; entrance platform sits on it
 COLUMN_D = 0.95         # Ionic shaft diameter at the base
 CAPITAL_H = 0.95
-ENTABLATURE_H = 3.40    # band between the capitals and the motto panel
-PARAPET_H = 2.20        # motto panel and cornice above the entablature
+ENTABLATURE_H = 3.00    # band between the capitals and the motto panel
+                        # 3.40 -> 3.00 on 2026-11-09: the photographs put the
+                        # colonnade at 50-60 % of the 14.5 m elevation, and our
+                        # 3.40/2.20 entablature+parapet left it at 47.6 %. Thinning
+                        # both lifts the colonnade to 7.70 m = 53.1 %, inside the band.
+PARAPET_H = 1.80        # motto panel and cornice above the entablature (see above)
 PORTAL_W = 3.10         # each of the three door openings
 PORTAL_H = 3.40
 STEP_TREAD = 0.34
@@ -241,10 +245,17 @@ 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

Tools/tests/README.md

@@ -0,0 +1,26 @@
+# Tooling tests
+
+Standard-library `unittest` tests for the host-side tools in `Tools/`. They never start Blender, Unreal, or the game; anything that needs those processes is verified by the tool itself and recorded in `Docs/release-checks.md` instead.
+
+Run from the repository root:
+
+```bash
+python3 -m pip install -r requirements-tools.txt
+python3 -m unittest discover -s Tools/tests -t Tools -p 'test_*.py'
+```
+
+The `-t Tools` top-level directory is required: the tests import the tool modules by their plain names (`import input_emulation`), which is why `Tools/tests/` carries an `__init__.py`.
+
+Individual test:
+
+```bash
+python3 -m unittest Tools.tests.test_input_emulation -v
+```
+
+## What belongs here
+
+Test the **pure** parts — argument parsing, key/coordinate encoding, geometry maths, licence gating, report formatting, decision classification. Network, Blender and Unreal calls stay out: a test that needs a paid API, a display, or an engine process is a manual check, not a unit test.
+
+When a tool's logic is buried in `main()`, extract it into a function so it can be tested directly. That is a tooling improvement, not test scaffolding.
+
+Geo (`Geo/tools/`) and Blender (`Art/blender/*/`) builders are tested the same way once their pure parts are extracted; note the module path in the test.

Tools/tests/__init__.py

@@ -0,0 +1 @@
+"""Package marker so `python3 -m unittest Tools.tests.<module>` resolves."""

Tools/tests/test_block_height_report.py

@@ -0,0 +1,59 @@
+"""Tests for Geo/tools/block_height_report.py::classify_height.
+
+The Geo tools live outside `Tools/`, so the test adds `Geo/tools` to `sys.path`
+before importing the module by name.
+"""
+
+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, "Geo", "tools"))
+
+import block_height_report as bhr  # noqa: E402
+
+
+class ClassifyHeightTest(unittest.TestCase):
+    def test_height_tag_wins(self):
+        height, source = bhr.classify_height({"building": "yes", "height": "18.1"})
+        self.assertEqual(height, 18.1)
+        self.assertEqual(source, "height tag")
+
+    def test_height_tag_beats_levels(self):
+        height, _ = bhr.classify_height(
+            {"building": "yes", "height": "12.5", "building:levels": "4"})
+        self.assertEqual(height, 12.5)
+
+    def test_levels_derive_height(self):
+        height, source = bhr.classify_height(
+            {"building": "yes", "building:levels": "4"}, level_height=3.2)
+        self.assertEqual(height, 12.8)
+        self.assertIn("levels x", source)
+
+    def test_roof_is_not_a_building_volume(self):
+        # building=roof at layer=1 is an elevated canopy, not a two-storey block.
+        height, source = bhr.classify_height({"building": "roof", "layer": "1"})
+        self.assertEqual(height, 0.0)
+        self.assertIn("not a building volume (roof)", source)
+
+    def test_canopy_is_not_a_building_volume(self):
+        # building=canopy at layer=1, found by the Mapbox cross-check.
+        height, source = bhr.classify_height({"building": "canopy", "layer": "1"})
+        self.assertEqual(height, 0.0)
+        self.assertIn("not a building volume (canopy)", source)
+
+    def test_transit_shelter_is_not_a_building_volume(self):
+        height, source = bhr.classify_height(
+            {"building": "yes", "amenity": "shelter", "shelter_type": "public_transport"})
+        self.assertEqual(height, 0.0)
+        self.assertIn("not a building volume (shelter)", source)
+
+    def test_missing_data_falls_back_to_a_flagged_guess(self):
+        height, source = bhr.classify_height({"building": "yes"})
+        self.assertEqual(height, 2 * bhr.LEVEL_HEIGHT)
+        self.assertTrue(source.startswith("GUESS"))
+
+
+if __name__ == "__main__":
+    unittest.main()

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_input_emulation.py

@@ -0,0 +1,57 @@
+"""Tests for Tools/input_emulation.py — the pure ioctl/key-code parts.
+
+The device path itself needs /dev/uinput, so only the encoding helpers are
+covered here; the end-to-end injection is verified by running the tool (see
+Docs/release-checks.md and MEMORY.md).
+"""
+
+import unittest
+
+import input_emulation as ie
+
+
+class IocEncodingTest(unittest.TestCase):
+    """_IOC must match the Linux ioctl bit layout."""
+
+    def test_layout_constants(self):
+        self.assertEqual(ie._IOC_NRSHIFT, 0)
+        self.assertEqual(ie._IOC_TYPESHIFT, 8)
+        self.assertEqual(ie._IOC_SIZESHIFT, 16)
+        self.assertEqual(ie._IOC_DIRSHIFT, 30)
+
+    def test_known_values(self):
+        # UI_SET_EVBIT = _IOW('U', 100, int) -> 0x40045564 on Linux.
+        self.assertEqual(ie.UI_SET_EVBIT, 0x40045564)
+        # UI_DEV_CREATE = _IO('U', 1) -> 0x5501.
+        self.assertEqual(ie.UI_DEV_CREATE, 0x5501)
+
+    def test_type_accepts_char_or_int(self):
+        self.assertEqual(ie._ioc(1, 4, "U", 100), ie._ioc(1, 4, ord("U"), 100))
+
+
+class KeyCodeTest(unittest.TestCase):
+    """KEYCODES must hold the Linux input-event codes the demo uses."""
+
+    EXPECTED = {
+        "w": 17, "s": 31, "a": 30, "d": 32,
+        "space": 57, "r": 19, "esc": 1,
+    }
+
+    def test_demo_controls(self):
+        for name, code in self.EXPECTED.items():
+            self.assertEqual(ie.KEYCODES[name], code, f"{name} code")
+
+    def test_lookup_is_case_insensitive(self):
+        dev = ie.InputDevice.__new__(ie.InputDevice)  # no device opened
+        self.assertEqual(dev._key_code("W"), 17)
+        self.assertEqual(dev._key_code("SPACE"), 57)
+        self.assertEqual(dev._key_code(19), 19)  # a raw code passes through
+
+    def test_unknown_key_raises(self):
+        dev = ie.InputDevice.__new__(ie.InputDevice)
+        with self.assertRaises(ie.UInputError):
+            dev._key_code("not-a-key")
+
+
+if __name__ == "__main__":
+    unittest.main()

Tools/tests/test_mapbox_buildings.py

@@ -0,0 +1,117 @@
+"""Tests for Geo/tools/mapbox_buildings.py — the pure merge logic.
+
+No network calls here: Tilequery responses are represented as the small dicts
+the API returns, and only the selection/comparison/formatting helpers are
+exercised. The live call is verified by running the tool.
+"""
+
+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, "Geo", "tools"))
+
+import mapbox_buildings as mb  # noqa: E402
+
+
+def feature(distance, height=None, min_height=0, type_="building", layer="building"):
+    props = {"tilequery": {"distance": distance, "layer": layer}}
+    if height is not None:
+        props["height"] = height
+    props["min_height"] = min_height
+    props["type"] = type_
+    return {"properties": props}
+
+
+class NearestBuildingTest(unittest.TestCase):
+    def test_picks_the_closest_building(self):
+        payload = {"features": [feature(6.0, 10.0), feature(1.0, 20.0)]}
+        best = mb.nearest_building(payload, max_distance=8.0)
+        self.assertEqual(best["height"], 20.0)
+
+    def test_ignores_hits_beyond_max_distance(self):
+        payload = {"features": [feature(20.0, 10.0)]}
+        self.assertIsNone(mb.nearest_building(payload, max_distance=8.0))
+
+    def test_ignores_other_layers(self):
+        payload = {"features": [feature(0.0, 10.0, layer="road")]}
+        self.assertIsNone(mb.nearest_building(payload, max_distance=8.0))
+
+    def test_no_features(self):
+        self.assertIsNone(mb.nearest_building({"features": []}, max_distance=8.0))
+
+
+class CompareTest(unittest.TestCase):
+    def test_match_within_half_a_metre(self):
+        self.assertEqual(mb.compare(14.5, "height tag", 14.2)[0], "match")
+
+    def test_close_within_two_metres(self):
+        verdict, delta = mb.compare(38.4, "levels x 3.2 m", 37.2)
+        self.assertEqual(verdict, "close")
+        self.assertAlmostEqual(delta, -1.2)
+
+    def test_disagree_beyond_two_metres(self):
+        verdict, delta = mb.compare(6.4, "GUESS: default 2 levels x 3.2 m", 3.0)
+        self.assertEqual(verdict, "disagree")
+        self.assertAlmostEqual(delta, -3.4)
+
+    def test_mapbox_only_when_we_have_nothing(self):
+        self.assertEqual(mb.compare(0.0, "height tag", 12.0)[0], "mapbox-only")
+
+    def test_ours_only_when_mapbox_returns_nothing(self):
+        self.assertEqual(mb.compare(12.0, "height tag", None)[0], "ours-only")
+
+    def test_non_building_is_excluded_from_comparison(self):
+        verdict, delta = mb.compare(0.0, "not a building volume (roof)", 3.0)
+        self.assertEqual(verdict, "non-building")
+        self.assertIsNone(delta)
+
+    def test_canopy_is_non_building(self):
+        verdict, _ = mb.compare(0.0, "not a building volume (canopy)", 3.0)
+        self.assertEqual(verdict, "non-building")
+
+
+class CentroidTest(unittest.TestCase):
+    def test_centroid_of_a_square(self):
+        lat, lon = mb.centroid_lat_lon(
+            [(34.0, -118.0), (34.0, -117.0), (35.0, -117.0), (35.0, -118.0)])
+        self.assertAlmostEqual(lat, 34.5)
+        self.assertAlmostEqual(lon, -117.5)
+
+
+class RenderTest(unittest.TestCase):
+    ARGS = type("A", (), {"radius": 25, "max_distance": 8.0, "only_diffs": False})()
+
+    def test_disagreements_sort_first(self):
+        rows = [
+            {"verdict": "match", "delta_m": 0.1, "way": 1, "name": "", "kind": "yes",
+             "osm_height_m": 10.0, "osm_source": "height tag", "mapbox_height_m": 10.1,
+             "mapbox_min_height_m": 0, "mapbox_type": "building",
+             "mapbox_distance_m": 0.0, "cached": True, "lat": 0, "lon": 0},
+            {"verdict": "disagree", "delta_m": -3.4, "way": 2, "name": "", "kind": "yes",
+             "osm_height_m": 6.4, "osm_source": "GUESS", "mapbox_height_m": 3.0,
+             "mapbox_min_height_m": 0, "mapbox_type": "building",
+             "mapbox_distance_m": 0.0, "cached": True, "lat": 0, "lon": 0},
+        ]
+        text = mb.render_markdown(rows, self.ARGS)
+        self.assertLess(text.index("way 2"), text.index("way 1"))
+
+    def test_never_contains_a_token(self):
+        rows = []
+        text = mb.render_markdown(rows, self.ARGS)
+        self.assertNotIn("access_token", text)
+        self.assertNotIn("sk.", text)
+
+
+class TokenTest(unittest.TestCase):
+    def test_explicit_token_wins(self):
+        self.assertEqual(mb.load_token("abc123"), "abc123")
+
+    def test_token_is_stripped(self):
+        self.assertEqual(mb.load_token("  abc123\n"), "abc123")
+
+
+if __name__ == "__main__":
+    unittest.main()

requirements-tools.txt

@@ -0,0 +1 @@
+requests>=2.28