experiment: LivingPlane repeatable + standalone UE runtime module (L164)

Readback barrier fix (GL_TEXTURE_UPDATE_BARRIER_BIT before glGetTexImage); check_repeatability.py compares full-field checksums across query/capture settings - Intel GPU PASS (3b9d45905c7aafff), llvmpipe PASS, mismatch control fails. New runtime module VoxelForgeLivingPlane (separate from generation): RDG global shader (Shaders/LivingPlane.usf), ping-pong RGBA32F render targets, actor with WPO plane and object inputs, no CPU readback. Compiles in Linux UE 5.7. Windows build: Source/VoxelForgeLivingPlane/*, Shaders/LivingPlane.usf, VoxelForge.uplugin. Setup: UE-SETUP.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
experiment: LivingPlane readable + alive mode (L163)
2026-11-02 11:10:43 +01:00 · 2026-11-02 10:55:32 +01:00 · 2026-11-02 10:35:37 +01:00 · 2026-11-01 04:11:52 +01:00 · 2026-11-01 01:37:58 +01:00 · 2026-10-31 02:40:58 +01:00
36 changed files with 3462 additions and 150 deletions
@@ -9,12 +9,20 @@
 !/Source/
 !/Source/**
 # Plugin runtime shader source.
 !/Shaders/
 !/Shaders/**
 # Portable CPU generator and D3D11 viewer.
 !/Standalone/
 !/Standalone/**
 /Standalone/Build/
 /Standalone/bin/
 # Research and prototype experiments.
 !/Experiments/
 !/Experiments/**
 # The guarded single-entry test harness is source, not generated output.
 !/Tools/
 !/Tools/**
@@ -0,0 +1,57 @@
 # AGENTS.md — VoxelForge (read automatically by Codex)
 You are the implementation agent. The orchestrator (Claude) writes each round's brief, reviews your diff against the
 code, and commits. The owner decides direction. Be warm and direct; credit what worked; say plainly what didn't.
 Read first, as the task needs: `CURRENT-STATE.md` (what ships, reference numbers, **closed experiments: don't reopen
 them without new evidence**), then `CODEMAP.md` and `ARCHITECTURE.md`. Round reports live in
 `Standalone/Research/WorldAssemblerM3/Linux*/REPORT.md`.
 ## Standing rules (every round, unless the brief says otherwise)
 - Run as user `jahni`. Write only inside this plugin, plus `/home/jahni/VFHost` and `/home/jahni/UnrealEngine` when
  the brief asks for a UE build. No installs, no system changes.
 - **No `git commit`, `push` or `stash`.** Leave changes in the working tree; the orchestrator reviews and commits.
 - Headless processes and builds: `taskset -c 0-11 prlimit --as=6442450944` (12 P-core threads, 6 GiB). Never use all
  cores.
 - Unreal (UBT, the editor, commandlets): `taskset -c 0-11` only, **never `prlimit`** (CoreCLR fails). UE builds use
  `-NoUBA -MaxParallelActions=4`, never while timing.
 - Stop any single run that passes 30 minutes. Logs go in `Saved/Linux/l<round>/`.
 - **Timing:** quiet machine only (check `uptime` first; load < ~1.5, nothing else building). L80 protocol: one warm-up
  per binary, ≥5 interleaved runs, W8 and W12, all four owner layers. Every number states the window that produced it.
 - **Same world for everyone:** a seed must give the same world on every machine and worker count (Clang and GCC,
  W1/W8/W12). Byte-identity with older versions is NOT required. If the output changes: bump
  `WorldAssemblyEvaluatorVersion`, add baselines, and show captures.
 - Density sign: negative = solid, positive = air. Core voxels are 25 cm. Never mix metres and voxels without an
  explicit conversion (v225 shipped a reach bug from exactly that).
 - The fast tier (`Standalone/Tools/verify/verify.py fast`) must stay green. Don't loosen an audit to make a change pass.
 ## How to work
 1. **Count before you build.** Measure where the time or the failure actually is (stack sampler, census, counters).
   State which parts are measured and which are inferred.
 2. **Suspect the measurement first.** An alarming or contradictory number is the instrument until a control rules it
   out (A/A runs, an ablation that verifiably removes the work).
 3. **No fix without a root cause.** Reproduce it, trace it to its source, fix the cause. A guard that hides the symptom
   is not a fix.
 4. **One change at a time,** each with its own check.
 5. **Subtract before you add.** Prefer removing work to reorganising it. The smallest edit that solves the problem.
 6. **Attack the premise.** When two fixes sharing one premise fail the same gate, write that premise in one sentence
   and question it before trying a third. **After three failed fixes, stop:** it is probably the design, not the
   hypothesis. Report it instead of trying fix #4.
 7. **Tests must be able to fail.** Name what would make each check fail. Add a negative control when you add an audit.
 8. **Refactors:** pin the behaviour (hashes), change the structure, prove nothing changed.
 9. **Verify before you claim.** Don't report a check as passed unless it ran on the final source. Say which checks
   didn't run and why.
 10. Changes that speed things up go in the shared layer, so every generator benefits.
 ## Report
 Write the round's `REPORT.md`, short and plain:
 - the result first;
 - what changed and why;
 - the measurements, with their windows;
 - the checks run, and those not run;
 - remaining risks.
 List any changed Unreal `Source/` files, because the owner compiles them on Windows.
@@ -1522,11 +1522,12 @@ collision ring became walkable at 0.632 s. `voxel.StreamingCoarseFirst=1` with
 residency by about one third on the staged plan, but null-RHI residency does not prove rendered
 enclosure. Keep coarse-first opt-in until that view is checked in a rendered owner-plan run.
-The separate `voxel.StreamingStartupApplyBoost` switch stays default-off. At `1`, it temporarily allows
+The separate `voxel.StreamingStartupApplyBoost` switch is default-on in the current code. At `1`, it
-12 visible mesh submissions / 14 ms while the initial desired set and walkable ring are incomplete,
+temporarily allows up to 24 visible mesh submissions / 14 ms while the initial desired set and
-with a 30 second ceiling; at `0`, the authored budget is unchanged. On the matched legacy-order test,
+walkable ring are incomplete, with a 30 second ceiling; at `0`, the authored budget is unchanged.
-the boost changed full-set readiness from 17.412 s to 17.346 s and removed count-cap frames, but did
+The historical matched S6 run changed full-set readiness from 17.412 s to 17.346 s and removed
-not improve end-to-end residency. Keep the normal 4 / 2 ms guard for play.
+count-cap frames, but did not improve end-to-end residency. These current defaults are defined in
 `Source/VoxelForge/Private/VoxelWorld.cpp`; the S6 measurement remains historical context.
 The S6 trace found the shared pool was not saturated: its 10-slot idle estimate was about 132
 slot-seconds on legacy order and 73 on gated coarse-first, while game-thread tile applies totaled only
@@ -1556,8 +1557,8 @@ by its RAII guard when the worker lambda exits. This still counts queued and run
 results do not consume an admission slot. `voxel.StreamingLegacyPendingResultCap=1` restores the old
 `PendingTiles` accounting; the test harness's `NearReserveMode=Legacy` also sets
 `voxel.StreamingDynamicNearReserve=0`, reproducing the S6 path. `StreamingDynamicNearReserve` now
-defaults to `1`; `StreamingCoarseFirst` remains `0`, and the apply boost remains `0` in the matched
+defaults to `1`; `StreamingCoarseFirst` remains `0`. That historical S6 matched measurement disabled
-measurement.
+the startup apply boost (`voxel.StreamingStartupApplyBoost=0`); the current default is on (§8.27).
 On the 2,578-key owner SurfaceWorld trace, the old-path control reached the full set in 17.527 s,
 walkable ring in 0.650 s, and full LOD0 in 2.281 s. Dynamic admission reached them in 7.780 s,
@@ -10,6 +10,7 @@ then wait for his results / pasted errors. Same for in-editor checks — ask for
 try to run anything.
 ## Read first (in order, load only what the task needs)
 - **[CURRENT-STATE.md](CURRENT-STATE.md) — current shipping snapshot and verification entry point.**
 - **[CODEMAP.md](CODEMAP.md) — ALWAYS.** Navigation: what it is, data-flow (§2), symbol→`file:line`
  index (§3), "I want to change X → go here" (§5), conventions & gotchas (§6). Trust **symbol names
  over line numbers** (lines drift).
@@ -388,7 +388,7 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `AdvanceHeadlessDigMotionTest` / `RecordHeadlessDigMotionFrame` | 3060 / 3217 | Explicit `-voxel.TestDigMotion=1` repro: optional near digs, then repeats underfoot digs and samples `Generator->GetDensityAt` immediately after each edit, on its first subsequent simulated frame, and on every following observation frame. `-voxel.TestDigMotionFieldOverride=1` is a measurement-only prototype that clears `CurrentFloor` and switches CMC to falling when the sampled post-edit density is air; it is inactive by default. The test counts false support, false air and downward velocity beyond one gravity step. `-voxel.TestDigMotionUnderfootDigCount` is clamped to 1–100; `-voxel.TestDigMotionUnderfootIntervalSeconds=0` performs per-frame rapid edits. The accompanying gap audit is scoped to the dig session. |
 | `MaybeFinishHeadlessStreamingTest` | — | The existing `voxel.TestExitSeconds` diagnostic emits `VoxelForgeStreamingExitDiag` at most every 30 elapsed seconds, including threshold and early-return test flags; no output when the timer is unconfigured. |
 | `UpdateVisualStalenessAudit` | 5034 | Test-only camera-frustum coverage audit: tracks up to 24 real pre-skirt isosurface points per visible component, then counts frames where no visible tile component covers a previously visible, still-desired point (excluding edited bounds). `voxel.TestVisualGapInjectEarlyHide=1` hides a valid component for three frames and must be caught. `voxel.TestGapAuditLegacyHandoff=1` restores old handoff culling for A/B baselines. |
-| `ProcessPendingChunks` | 7435 | Drains `CriticalProcessQueue`, `EditedProcessQueue`, `NearProcessQueue`, then `ProcessQueue`; applies under the authored 4-mesh/2 ms budget during normal play and the bounded shared startup budget (12 meshes/14 ms) until the initial desired set and walkable ring are ready. `voxel.StreamingStartupApplyBoost=0` restores the authored budget. `startup_apply_config` traces the actor-read CVar and both budgets; `startup_apply_budget` records activation/end. Reads per-request cancellation before removing its map entry, traces stale/obsolete/aborted discards with epoch and ordinal, then applies via `ApplyTileResult`. Step 1 prequeue still releases here and emits `VFStep1UploadCorpusReleased`. |
+| `ProcessPendingChunks` | 7435 | Drains `CriticalProcessQueue`, `EditedProcessQueue`, `NearProcessQueue`, then `ProcessQueue`; applies under the authored 4-mesh/2 ms budget during normal play and the default-on bounded startup budget (24 meshes/14 ms, at most 30 s) until the initial desired set and walkable ring are ready. `voxel.StreamingStartupApplyBoost=0` restores the authored budget. `startup_apply_config` traces the actor-read CVar and both budgets; `startup_apply_budget` records activation/end. Reads per-request cancellation before removing its map entry, traces stale/obsolete/aborted discards with epoch and ordinal, then applies via `ApplyTileResult`. Step 1 prequeue still releases here and emits `VFStep1UploadCorpusReleased`. |
 | `ApplyTileResult` | — | **Shared game-thread apply** for one `FChunkResult` (async drain + sync carve): discards stale generation epochs and keys no longer desired, marks loaded, ingests capture, EMPTY releases the tile's existing component (a re-gen can flip content→empty on band change — old geometry must not linger), else `ApplyMeshToTile`. Returns true iff a visible mesh uploaded (counts the budget). Doesn't touch `PendingTiles` (caller's). |
 | `FVoxelStackSampler` / `FScopedVoxelStackRegistration` (`VoxelStackSampler.h/.cpp`) | — | **Diagnostic raw stack sampler, off by default.** A sampler thread captures registered generation workers' stacks (`CaptureThreadStackBackTrace`) every N µs and tags each with the tile's LOD. It writes bounded raw PCs to CSV plus a symbolization-free summary under `Saved/`; symbol resolution is deferred until after process exit so the measured process never initializes/calls DbgHelp for this diagnostic. Lifecycle teardown is serialized and registration TLS is session-tagged. Registration is per tile TASK in `LoadTile` (and the export's tasks), never per sample; disabled costs one relaxed atomic load. Game `-voxel.SampleStacks=<us>`, commandlet `-samplestacks[=us]`. |
 | Room-cache performance (2026-09-13): `VF_FindPlayerFitPointForRoomMemoized` / `GPlayerFitMemo` (`VoxelCaveMorphology.cpp`), `voxel.TileCacheWindow` + `VoxelGenLOD::TileOriginVoxels/TileCellsPerAxis` (`VoxelGenerator.h`), `FChunkSDFSpatialIndex` | — | **Player-fit memo:** exact 97-word key, process-wide, `voxel.PlayerFitMemo`. **Tile cache window:** the room cache covers the requesting tile's footprint plus a fixed collect margin. It is set via `TGuardValue` in `GenerateMesh`/classify, and is window-invariant by construction (the margin does not grow with the tile). **LOD-gated:** fused path at LOD ≥ `voxel.TileCacheWindowMinLOD` (3), op-stack at LOD ≥ `voxel.TileCacheWindowOpStackMinLOD` (4); lower LODs keep the 4-chunk worker window, because the tile window slowed LOD0 evaluation ~6%. Strates whose authored terrain ops exceed the proven 256-voxel extent (or are malformed/unloaded) fall back to the legacy window (`VF_ComputeTerrainOpEnvelope`). `voxel.SpatialIndex` is -1 auto (off at fused LOD0, on elsewhere), 0 or 1. **Spatial index:** ordered XY buckets over cache primitives, exact rejection. The `static_assert` in `VoxelStrateTypes.h` ties `VF_STRATE_PARAM_FIELDS` to `FStrateGenerationParams` (83 fields + 8 B padding). |
@@ -396,7 +396,7 @@ casse cette arithmetique *structurellement* — `BeginPlay` loggue une **Error**
 | `RecordTileHash` / `WriteTileHashDump` | — | Headless `-voxel.TileHashDump=<absolute path>` parity instrument. Records the exact `FVoxelMeshData` used by the streaming result, including empty/classified tiles, then writes sorted absolute tile keys, LOD step/cells, content-band limits, settings digest context, and the shared `VoxelGeometryHash` at `EndPlay`. |
 | `SyncRemeshTile` | — | **INSTANT DIG**: level-0 same-frame re-mesh on the game thread. Uses `PreEditDensityCache` when the tile is resident in the bounded local cache, replays the current DiffLayer over that exact procedural lattice, then meshes/applies inline so a carve is visible THIS frame. A cache miss uses normal generation; it captures the unedited lattice if the tile needs meshing, while uniform-tile proofs remain enabled. |
 | `PreEditDensityCache` / `VoxelForgePreEditDensityCache::BuildEditedGrid` | — | Per-world cache of the pawn's current L0 tile: exact 35³ pre-edit samples, max **171,500 bytes**. It is pruned when the pawn crosses chunk boundaries and cleared on `RegenerateAllChunks`. `BuildEditedGrid` snapshots touched diff chunks once and reproduces `GetDensityAt`'s final `pre-edit - EvaluateMods` operation before the per-call shared-grid mesher path. |
-| `UpdateChunksAroundPosition` / `GetGenerationAdmissionCount` | 10990 / 10971 | Shared Core/legacy scheduler. Builds the desired set and delta-culls leavers; admits the occupied/support tile plus collision-required LOD0 tiles in the pawn's 3×3 XY ring as `CollisionCritical`. S5 coarse-first admission stays opt-in (`voxel.StreamingCoarseFirst=1`). `voxel.StreamingDynamicNearReserve=1` is now the default: it keeps the authored near reserve while moving or until the stationary walkable ring is ready, then makes those slots available to coarse work. Admission counts submitted queued/running tasks, not completed results waiting in the MPSC result queues; `voxel.StreamingLegacyPendingResultCap=1` restores the old `PendingTiles`-based cap for the negative control. `PendingTiles` still lasts through game-thread apply for duplicate suppression and result bookkeeping. The clipmap stays non-overlapping and load-before-unload / `TransitionHold` reconciliation remains authoritative. Standalone has no mirror of this actor scheduler. §8.10 + §8.26–8.28. |
+| `UpdateChunksAroundPosition` / `GetGenerationAdmissionCount` | 10990 / 10971 | Shared Core/legacy scheduler. Builds the desired set and delta-culls leavers; admits the occupied/support tile plus collision-required LOD0 tiles in the pawn's 3×3 XY ring as `CollisionCritical`. S5 coarse-first admission stays opt-in (`voxel.StreamingCoarseFirst=1`). `voxel.StreamingDynamicNearReserve=1` is the default: it keeps the authored near reserve while moving or until the stationary walkable ring is ready, then makes those slots available to coarse work. Admission counts submitted queued/running tasks, not completed results waiting in the MPSC result queues; `voxel.StreamingLegacyPendingResultCap=1` restores the old `PendingTiles`-based cap for the negative control. `voxel.StreamingFarApplySupplement=1` is the default L121 lane: after the visible-apply cap, at most one far result is admitted when under half the apply-time budget and startup boost is inactive. `PendingTiles` still lasts through game-thread apply for duplicate suppression and result bookkeeping. The clipmap stays non-overlapping and load-before-unload / `TransitionHold` reconciliation remains authoritative. Standalone has no mirror of this actor scheduler. §8.10 + §8.26–8.28. |
 | `AdvanceHeadlessCollisionGateStressTest` / `ObserveHeadlessCollisionGateStressTest` / `MaybeFinishHeadlessCollisionGateStressTest` / `MeasureHeadlessCollisionGateStressTerrain` | — | Explicit `-voxel.TestCollisionGateStress=1` harness only. The normal spawn-height cvar offsets from the measured density surface; `voxel.TestCollisionGateStressDeepDrop=1` carves a process-local box shaft from above the top to just above the floor tile, extending along the post-landing route so the pawn does not run into the shaft sidewall, temporarily raises only the transient test DiffLayer brush-radius allowance for that fixture, removes only the local pawn's redundant streaming anchor for this isolated repro, proves every sample in two complete outside-ring level-0 tiles is air before seeding their known-empty status, prewarms the known-empty in-ring column, and asserts that the support walk reaches the in-layout floor outside the aligned level-0 render ring before the pawn drops. The log reports whether the fixed gate retains that otherwise out-of-ring target. Other streaming anchors remain active. The fixture rejects a target or floor outside the layout, a non-air empty-tile proof, or a floor inside the aligned level-0 ring. The `GetDensityAt` column at capsule feet defines the local air/solid surface; the deep-drop column crossing is cached after its first exact scan. Each frame records actor position, velocity, direct foot tile and gate support readiness, gate state, signed feet clearance, and a ≤0.5-voxel sweep between positions. PASS requires no measured clearance below −5 cm; deep-drop gate-on also requires horizontal travel during a hold. Result logs include the terminal density column, first crossing below spawn height, hold count/time, and gated horizontal progress. |
 | `BuildDesiredTiles` | 6482 | Builds `DesiredSorted`+`DesiredStamped` (player clipmap shells), then adds streaming anchors and the pending player's collision-only support column before the leaver sweep. It orders from the true local pawn position and builds `CriticalDesiredTiles` for the unresolved support target, occupied/support and heading tiles. Also rebuilds `DesiredTransitionDescendants` (ancestor → desired descendants, including face/edge-touching replacements) for the reconcile pass. |
 | `CollisionGateDesiredTiles` / `RequestCollisionGateSupportTile` | 5062 | Retains an unresolved support target and up to three level-0 tiles below it across desired-set rebuilds. The additional keys are hidden collision-only tiles, queued ahead of ordinary streaming, and pruned once resolved or outside the active column. |
@@ -0,0 +1,57 @@
 # VoxelForge current state
 As of 2026-10-31. L131 is on `assembler/world` as `8107196`; this L132 worktree is on `wip/l132-dispatch-truth`, starting at `ebae71b`. Current-state claims below point to their code or measured report.
 ## What ships today
 - **Core:** evaluator version **227**. Unreal's `AVoxelWorld::bUseVoxelForgeCore` is opt-in and defaults to `false`; the legacy generator remains the default runtime path. [Core version](Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h), [runtime switch](Source/VoxelForge/Public/VoxelWorld.h), [L130 report](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
 - **Verified owner4 generator dispatch (L132):** SW binds `SurfaceWorld-native` because the owner export contains a matching `SurfaceWorld.Heightfield2D` v2 plan. FI binds `compiled-analytic/FloatingIslands` because its `FloatingIslands.ClusterField` v0 layout has no matching native island plan. TN and VS bind `compiled-analytic/TunnelNetwork` and `compiled-analytic/VerticalShafts`; their legacy recipe IDs provide neither a `NativeCaves`/`NativeLattice` graph recipe nor native field capability. The L132 fast-tier report prints the binding and generated tile-center share at each owner strate. [Dispatch](Standalone/Core/src/ShapeWorldInternal.h), [adapter recipe checks](Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h), [L132 report](Standalone/Research/WorldAssemblerM3/Linux132/REPORT.md).
 - **Passages:** continuous smooth swept tubes with a continuous floor profile. L125 stamps conservative route slabs and outside sentinels into the tile cache; exact route geometry is still evaluated. All 21,425 route samples passed the open-air walk check; the nine-station floor probe's maximum root offset was 7.884 mm. L130 sets the shared influence reach to **1.0533 m** (0.75 m shell + 0.21 m relief + 0.50 m smooth-max support / 6 + 0.01 m margin), converted once from metres to Core voxels for the proof, feature, fallback, and off-grid bounds. [L125](Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md), [L130](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
 - **Streaming:** arrival uses a bounded startup apply burst: `voxel.StreamingStartupApplyBoost=1` by default, up to 24 visible meshes or 14 ms per frame for at most 30 seconds, until the initial desired set and walkable ring are ready. `voxel.StreamingFarApplySupplement=1` is also default-on: after the normal visible apply cap, at most one far result applies when under half the apply-time budget; it is inactive during the startup burst. Dynamic near reserve defaults on; coarse-first remains off; the legacy pending-result cap defaults off. The far-apply lane is Unreal-only. [CVar source](Source/VoxelForge/Private/VoxelWorld.cpp), [L121 report](Standalone/Research/WorldAssemblerM3/Linux121/REPORT.md), [architecture](ARCHITECTURE.md).
 - **Determinism:** proven on Linux with Clang and GCC at W1/W8/W12. L131's unchanged-output comparison covers owner4's SW/FI/TN/VS views in 24 compiler/worker cases; the canonical owner4/owner2 recipe matrix also passes. Windows determinism is unverified. [L131 checks](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md), [v227 canonical hashes](Standalone/Tools/verify/baselines/owner-hash/canonical/).
 ## Current performance references
 Headless medians in seconds, five interleaved L80-style measurements per version in each cell. Near-ready means the complete LOD0–2 set; whole-view is the full requested view. Values below are the edited L131 binary; the paired pre-cleanup comparison is in the [L131 report](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md) and [timing summary](Saved/Linux/l131/timing/summary.json).
 | Stratum | Near-ready W8 / W12 | Whole-view W8 / W12 |
 |---|---:|---:|
 | S0 | 0.804 / 0.848 | 1.811 / 1.832 |
 | S1 | 1.014 / 1.002 | 1.993 / 1.886 |
 | S2 | 1.060 / 1.012 | 1.960 / 1.865 |
 | S3 | 0.917 / 0.884 | 1.887 / 1.782 |
 Across 40 paired runs per metric, the mean relative change from pre-cleanup L130 was −0.22% near-ready (95% CI −1.02% to +0.57%) and −0.29% whole-view (−1.04% to +0.46%); neither indicates a measurable slowdown. The machine gate was load 0.81 and 99.2% idle. [L80 protocol](Standalone/Research/WorldAssemblerM3/Linux80/REPORT.md), [runner and raw runs](Standalone/Research/WorldAssemblerM3/Linux131/RunL131Timing.py).
 The latest recorded Linux Unreal start-to-LOD0–2 values are L127's one run per stratum: S0 2.456 s, S1 2.231 s, S2 2.514 s, S3 2.221 s. L130 did not rerun UE startup or movement. Five L127 runs at 30 m/s, 12 s moving plus 5 s dwell, had median moving near coverage **40.22%**, far holes **3.46%**, tick p99 **10.80 ms**, and worst tick **13.27 ms**. After stopping, near coverage reached 100% and far holes reached 0%. These are the latest UE references, not v227 UE measurements. [L127 report](Standalone/Research/WorldAssemblerM3/Linux127/REPORT.md), [L127 movement summary](Saved/Linux/l127/ue/movement-pairs-summary.json), [L127 start summaries](Saved/Linux/l127/ue/merge/start-summary.json).
 ## Open gaps
 - Multiplayer world lifecycle is unfinished: seed/layout replication, authoritative modification RPCs, and serialized diff replay for late join are still open. See [ARCHITECTURE §9.5 and §9.7](ARCHITECTURE.md).
 - Determinism has not been verified on Windows. Linux Clang/GCC agreement does not establish MSVC agreement.
 - NullRHI measures residency and apply timing, not the first presented pixel or rendered enclosure. L127 also found four low-contrast views among 23 otherwise verified captures. [L121](Standalone/Research/WorldAssemblerM3/Linux121/REPORT.md), [L127](Standalone/Research/WorldAssemblerM3/Linux127/REPORT.md).
 - UE startup/movement numbers above predate L130's v227 reach change; there is no L130/L131 UE movement comparison.
 ## How to verify
 - Build standalone Clang or GCC with [`Standalone/BuildLinux.sh`](Standalone/BuildLinux.sh), for example `bash Standalone/BuildLinux.sh --compiler=clang++-19 --variant=l132-clang --fp-contract=off --jobs=4`. The script pins CPUs 0–11 and applies `prlimit --as=6442450944` itself.
 - Fast tier: `python3 Standalone/Tools/verify/verify.py fast --out Saved/Linux/l132 --overall-timeout 1740`. It includes the L132 four-pose owner density-dispatch report; per-run logs and the summary stay under `Saved/Linux/l132`.
 - Canonical output baselines are the v227 files in `Standalone/Tools/verify/baselines/owner-hash/canonical/`. L131 also provides reproducible pre-cleanup identity matrices for owner4 tile hashes and owner4/owner2 canonical hashes under `Standalone/Research/WorldAssemblerM3/Linux131/`.
 - Timing follows L80: quiet machine, no overlapping build, one warm-up per version, five interleaved runs per stratum and worker count, W8/W12. Each headless run uses `taskset -c 0-11`, `prlimit --as=6442450944`, and a 1,740 s timeout. See [`RunL131Timing.py`](Standalone/Research/WorldAssemblerM3/Linux131/RunL131Timing.py).
 - Linux host build: `/home/jahni/UnrealEngine/Engine/Build/BatchFiles/Linux/Build.sh VFHostEditor Linux Development -Project=/home/jahni/VFHost/VFHost.uproject -NoUBA -MaxParallelActions=4 -Log=/home/jahni/VoxelM/Plugins/VoxelForge/Saved/Linux/l131/ubt.log`. Run Unreal without `prlimit`.
 ## Closed experiments
 These rejected speed/streaming proposals stay closed unless new evidence changes their measured failure. Reports and surviving patches are linked in the [L131 inventory](Standalone/Research/WorldAssemblerM3/Linux131/REPORT.md).
 | Line | Result |
 |---|---|
 | L116 tunnel chord bound and z cache | Pair count fell 20.8%, but stayed 1.96× L109 and readiness was 15–30% slower. Patch: [`chord-bound-zcolumn-not-merged.patch`](Standalone/Research/WorldAssemblerM3/Linux116/patches/chord-bound-zcolumn-not-merged.patch), commit `89504ec`; see [report](Standalone/Research/WorldAssemblerM3/Linux116/REPORT.md). |
 | L118 pair pruning / deferred floor work | Pruned 17–18% of candidate pairs but remained 17.2–25.7% behind L109 near-ready. [Report](Standalone/Research/WorldAssemblerM3/Linux118/REPORT.md); patch: [`l118-designs.patch`](Standalone/Research/WorldAssemblerM3/Linux118/l118-designs.patch). |
 | L126 floor-call filters | Cut floor calls 20–23% without reducing pair counts; all eight cells missed L109. Candidate source was restored and no standalone patch was kept; see [report](Standalone/Research/WorldAssemblerM3/Linux126/REPORT.md) and commit `01a5094`. |
 | L128 half-open slab ownership | Ownership audit passed, but readiness was 14.8–28.0% behind L109 and moving coverage dropped. Report and patch `l128-slab-ownership.patch` are in archived commit `7022d02`. |
 | L129 2 m physical reach | v225's metre/Core-voxel bounds mismatch made the correctly bounded candidate do more work; it was slower and failed UE movement gates. Report and patch `l129-reach-2m.patch` are in archived commit `0d1140c`. |
 | L120 priority split / extra worker slots | Neither met coverage and tick gates; 10 slots reached a 16.67 ms worst tick against 15.43 ms baseline. [Report](Standalone/Research/WorldAssemblerM3/Linux120/REPORT.md); no production patch retained. |
 | L122 admission relaxation | Early admission missed p99 or far-hole gates; no behavior retained. [Report](Standalone/Research/WorldAssemblerM3/Linux122/REPORT.md); patch: [`l122-trace.patch`](Standalone/Research/WorldAssemblerM3/Linux122/l122-trace.patch). |
 | L123 lookahead / completion gate | Lookahead failed p99 and worsened near/far coverage; queue-only also failed p99. [Report](Standalone/Research/WorldAssemblerM3/Linux123/REPORT.md); patch: [`l123-queue-lookahead.patch`](Standalone/Research/WorldAssemblerM3/Linux123/l123-queue-lookahead.patch). |
 | L124 early LOD0 pages | Optimistic gain stayed below 100 ms except negative cases; no publication/scheduling implementation was made. [Report](Standalone/Research/WorldAssemblerM3/Linux124/REPORT.md). |
@@ -0,0 +1,201 @@
 # L162 — Living Plane
 The EGL/OpenGL 4.3 runner builds and passes its llvmpipe correctness and frame checks. The sandbox has no accessible DRM render node, so it did not run or report Intel GPU performance. The runner refuses `--device=gpu` here instead of falling back to software.
 ## Implementation
 `LivingPlane.cpp` runs a ping-pong `RG32F` height/velocity field through a runtime-compiled GLSL compute shader. The damped wave update includes a weak foundation spring, a Gaussian sphere push, and an optional slow breathing force. The spring is needed because a persistent local push otherwise accelerates the zero-frequency height mode and sinks the whole plane. The sphere moves across the plane, stops, and bobs. A vertex-displaced mesh and lit sphere render to an EGL pbuffer-backed framebuffer and save as PNGs.
 The timestep is selected from the largest 2D grid eigenfrequency:
 `dt = 1.30 / sqrt(8*c*c/(dx*dx) + foundationStiffness)`
 The resulting spectral step ratio is 1.30, below the explicit update's 2.0 stability limit. The runner warms the compute kernel for eight unmeasured dispatches, then records one `GL_TIME_ELAPSED` query per requested simulation step in `timing.json`.
 The first-step equation audit also caught a GL state error during bring-up: frame rendering left the graphics program active before the next compute dispatch. `Dispatch` now binds the compute program before every step, so the audit fails if a frame silently stops simulation.
 Device selection enumerates EGL devices and uses `EGL_EXT_platform_device` for an accessible Intel render node first. On this host, the known integrated device is Intel on `renderD128`. Automatic mode falls back to a surfaceless Mesa context with `LIBGL_ALWAYS_SOFTWARE=1`; explicit GPU mode fails when no accessible hardware node is present. EGL does not expose Vulkan's integrated/discrete enum, so Intel vendor/render-node identity is the selection heuristic.
 The Unreal handoff is in [UNREAL-MAPPING.md](UNREAL-MAPPING.md). It keeps the prototype render-only and describes the density mapping if the surface later needs to affect voxel queries. No Unreal `Source/` files changed.
 ## Measurements and checks
 - Built with `Experiments/LivingPlane/build.sh` using the installed EGL, desktop GL, and libpng development files; no shader compiler or package install was needed.
 - Final llvmpipe run: 128² field, 360 steps, `dt=9.56814 ms`, spectral ratio 1.30. The first-step equation audit and finite-field/dynamics audit passed. Final field range was −0.139533 m to +0.0366704 m. It wrote 16 128×128 PNGs and a JSON file containing 360 per-step query samples. The frames were inspected; the moving sphere and wake are visible.
 - Auto-selection smoke check: 32², 12 steps; selected llvmpipe and passed both audits. Breathing smoke check: 64², 180 steps with `--breathing=on`; passed both audits.
 - Negative device-selection control: `--device=gpu` returned an error because the sandbox has no accessible EGL DRM render node.
 - Existing fast verification tier passed: 278.9 seconds, ending in `SUMMARY PASS`. Its build and logs are under `Saved/Linux/l162/verify/` and `Saved/Linux/l162/`.
 - The llvmpipe `GL_TIME_ELAPSED` samples are preserved in JSON but are software-driver query values, not GPU timings. The requested hardware timing pass remains to be run outside the sandbox.
 - No Unreal build was run; no Unreal `Source/` files changed.
 ## Intel GPU pass
 Run these from the plugin root as `jahni`. The frame run writes 512×512 PNGs to `Saved/Linux/l162/gpu-frames-512/`; the two timing runs write `timing.json` with one GPU query per step and skip PNG capture. They still read the field for the first-step and final-state correctness audits.
 Before the timing runs, check `uptime` and run them on a quiet machine (load below about 1.5, with no other build active).
 ```sh
 uptime
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=512 --steps=1800 --capture-every=12 --out=Saved/Linux/l162/gpu-frames-512
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=512 --steps=1800 --capture-every=0 --out=Saved/Linux/l162/gpu-timing-512
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l162/living-plane --device=gpu --size=1024 --steps=1800 --capture-every=0 --out=Saved/Linux/l162/gpu-timing-1024
 ```
 Encode the captured sequence as MP4 with:
 ```sh
 ffmpeg -y -framerate 30 -i Saved/Linux/l162/gpu-frames-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l162/living-plane-512.mp4
 ```
 ## Files and remaining risk
 The only changed file outside `Experiments/LivingPlane/` is `.gitignore`, which now allows `Experiments/` and its contents. GPU timings and Intel render-node selection remain unverified until the commands above run on the host outside this sandbox.
 ## Intel GPU pass (run by the orchestrator outside the sandbox, 2026-11-02)
 - The device was selected correctly: `Mesa Intel(R) Graphics (ADL GT2)`, OpenGL 4.6, `/dev/dri/renderD128`. 512²,
  1,800 steps, 151 frames; the equation audit passes. MP4: `Saved/Linux/l162/living-plane-512.mp4` (local).
 - **The `GL_TIME_ELAPSED` per-dispatch values (~0.0001 ms) are not credible** for 262k cells, so they aren't
  reported as timings.
 - Wall-time difference between 1,800 and 200 steps, divided by the 1,600 steps (start-up cancels out; this includes
  submission, so it's an upper bound): **0.080 ms/step at 512²** and **0.292 ms/step at 1024²**.
 - Visual read: the effect is very subtle in the current render (a slight dip under the sphere, faint rings). It needs
  a larger push amplitude, grazing light or height colouring, and a closer camera to read.
 ## L163 — readable, living plane
 The plane now reads as rolling terrain, and the objects leave visible troughs and wakes. `alive` adds travelling
 breathing and a viscoelastic imprint that remains after lift-off. The simulation still runs in one GPU dispatch per
 step; CPU work only supplies the two object states.
 `LivingPlane.cpp` now keeps the dynamic displacement, velocity, and imprint in an `RGBA32F` ping-pong field. The
 surface shader adds broad static terrain relief, calculates normals from relief plus displacement, and uses grazing
 light, elevation colours, slope tint, and 7.5 cm contour bands. The camera follows the first sphere at a closer angle.
 The wake scene rolls the first sphere, pauses and wobbles it, lifts it, then sends a second sphere through the wake.
 The alive scene runs that same sequence with low-frequency travelling swells and a decaying contact imprint. Its
 defaults are breathing strength 4.8 m/s², imprint capture 0.15 m/s, recovery time 6 s, and maximum imprint depth
 0.34 m. These values have command-line overrides.
 The timer query check found no early read or reuse in L162: it allocated a unique query per step, called `glFinish`,
 then read every result. The saved Intel/Mesa 25.0.7 samples are 0 or 52 ns for most dispatches (512² median 0,
 p95 52 ns; largest sample 17.552 µs), which cannot be a credible per-dispatch cost. The old usage did not reuse
 query objects, so lifetime is not the cause; the saved data point to Intel/Mesa's timer-query reporting or timing
 scope, but the sandbox cannot isolate which. L163 uses a 64-query ring, reads each query before reusing its slot,
 checks availability after `glFinish`, and records `GL_QUERY_COUNTER_BITS`. On llvmpipe the availability check passed
 with 64 counter bits and zero waits. The Intel query result still needs the GPU diagnostic command below.
 ### Measurements and checks
 - llvmpipe wake: 128², 600 steps (`dt=9.56814 ms`, 5.741 s simulation window), 151 frames at 30 fps. First-step
  equation audit and timer-query lifetime check passed; final displacement range was −0.177488 m to +0.104854 m.
 - llvmpipe alive: same grid, steps, and window; equation audit and timer-query lifetime check passed. Final
  displacement range was −0.200437 m to +0.115904 m, with a −0.111667 m stored imprint.
 - llvmpipe cost: 512², 1,800 steps, `--queries=off`, no frame capture: **0.767473 ms/step** in one timed
  simulation-loop window. `timing.json` includes dispatch submission, the step-0 equation readback, and final
  `glFinish`, but excludes setup and frame capture. This is a software-renderer measurement, not the Intel GPU cost.
 - Both five-second llvmpipe previews are in `Saved/Linux/l163/llvmpipe-wake.mp4` and
  `Saved/Linux/l163/llvmpipe-alive.mp4`. They are 128² review previews; use the GPU commands below for the owner
  videos.
 - Equation-audit negative control: a temporary copy with its expected first-step height forced to zero exited FAIL
  at actual −0.0488777 m. The final source passes that same check.
 - The fast verification tier passed in 278.5 s. Build and logs are under `Saved/Linux/l163/verify/`.
 - No Unreal `Source/` files changed and no Unreal build ran.
 ### Intel GPU run
 Run from the plugin root as `jahni`. First build the runner. For timed runs, check `uptime` and keep the machine
 quiet. The wall-time field is valid only when `--capture-every=0`; use `--queries=off` for the step-cost measurement.
 ```sh
 bash Experiments/LivingPlane/build.sh
 uptime
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=wake --size=512 --steps=2400 --capture-every=16 --queries=off --out=Saved/Linux/l163/gpu-wake-512
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=2400 --capture-every=16 --queries=off --out=Saved/Linux/l163/gpu-alive-512
 ffmpeg -y -framerate 30 -i Saved/Linux/l163/gpu-wake-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l163/living-plane-wake-512.mp4
 ffmpeg -y -framerate 30 -i Saved/Linux/l163/gpu-alive-512/frame_%06d.png -c:v libx264 -pix_fmt yuv420p Saved/Linux/l163/living-plane-alive-512.mp4
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=1800 --capture-every=0 --queries=off --out=Saved/Linux/l163/gpu-timing-512
 taskset -c 0-11 prlimit --as=6442450944 -- timeout 1740s ./Saved/Linux/l163/living-plane --device=gpu --scene=alive --size=512 --steps=1800 --capture-every=0 --queries=on --out=Saved/Linux/l163/gpu-query-check-512
 ```
 `gpu-timing-512/timing.json` reports the 512² batch wall time per step, including dispatch submission and completion.
 `gpu-query-check-512/timing.json` contains query counter bits, waits before slot reuse, availability status, and raw
 per-step query samples. The sandbox has no accessible Intel DRM node, so the current Intel step cost and new query
 diagnostic remain unmeasured here.
 ### L163 Intel GPU pass (run by the orchestrator, 2026-11-02)
 - Intel ADL GT2 (Mesa 25.0.7, `renderD128`): wake and alive scenes, 512², 2,400 steps, 151 frames each; equation
  audits PASS. Videos (local): `Saved/Linux/l163/living-plane-wake-512.mp4`, `living-plane-alive-512.mp4`.
 - Step cost, alive scene, 512², 1,800 steps, no capture: **0.172 ms/step** with queries off, 0.152 ms/step with
  queries on (batch wall time per step).
 - The Intel `GL_TIME_ELAPSED` median is still 0 with 64 counter bits and the ring/availability checks passing. That
  looks like a Mesa/Intel reporting issue; use wall time.
 - **Open issue:** the same scene with the same steps gave different final fields (min −0.637 m with queries off vs
  −0.327 m with queries on). Something depends on more than the step index (e.g. wall-clock time); investigate.
 ## L164 — repeatable field readback and UE runtime actor
 **Result:** the repeatability check passes on llvmpipe, and the new `VoxelForgeLivingPlane` runtime module compiles
 in the Linux UE 5.7 host. The surface actor is independent of VoxelForge generation and sends no field readback to
 the CPU.
 ### Repeatability finding
 `uTime` is `Step * dt`, and `GetBodiesAt` receives that same value. Neither the object schedule nor the breathing
 force uses wall time or a rendered-frame counter. Every compute step already issued an image-access barrier before
 the next ping-pong image read. The defect was on the diagnostic side: the step-zero and final `glGetTexImage`
 readbacks followed shader image writes without `GL_TEXTURE_UPDATE_BARRIER_BIT`. The Khronos OpenGL specification
 requires that barrier for `GetTexImage` to observe earlier shader writes ([§7.12](https://registry.khronos.org/OpenGL/specs/gl/glspec44.compatibility.pdf)). Query/capture pacing could therefore affect the reported field values without changing any simulation input. The barrier is now issued before both readbacks.
 `check_repeatability.py` runs the same 512² alive scene for 1,800 steps twice: queries off with no captures, then
 queries on with captures every 900 steps. The checksum covers every final RGBA32F field value using canonical
 little-endian float bytes.
 - llvmpipe, queries off/capture off: field range −0.637382 m to +0.109308 m; checksum
  `1ba08f5dafc01f82`.
 - llvmpipe, queries on/capture every 900: the same range and checksum; equation and timer-query audits pass; three
  frames written.
 - Negative control: changing one saved checksum made the comparison exit 1 with `FAIL field checksum mismatch`.
 - The llvmpipe runs were each one 1,800-step simulation-loop window. Logs and JSON are under
  `Saved/Linux/l164/repeatability/`.
 The Intel run is not available in this sandbox. The owner should repeat the checksum comparison on the GPU to
 confirm that the missing transfer-readback barrier accounts for the earlier Intel min mismatch:
 ```sh
 python3 Experiments/LivingPlane/check_repeatability.py --device=gpu --out=Saved/Linux/l164/gpu-repeatability
 ```
 ### Unreal implementation and checks
 The plugin descriptor adds a separate `VoxelForgeLivingPlane` runtime module. Its RDG global shader is in
 `Shaders/LivingPlane.usf`; module startup maps `/Plugin/VoxelForgeLivingPlane` to the plugin shader directory. The
 actor owns two UAV-capable RGBA32F render targets, advances them at the stable fixed step, and supplies the current
 texture to a movable plane mesh material. Its Blueprint/C++ object input includes world position, radius, velocity,
 base push, and active state. The CPU converts those values to plane-local metres and uploads uniforms; it does not
 read the field back. The ignore rules now include `Shaders/` so that the shader ships in the worktree diff.
 `Experiments/LivingPlane/UE-SETUP.md` gives level setup, the full material graph, and object driving steps.
 - Linux UE 5.7 `VFHostEditor Linux Development`: **PASS**, final incremental build compiled
  `VoxelForgeLivingPlaneActor.cpp` and linked `libUnrealEditor-VoxelForgeLivingPlane.so`. Command used
  `-NoUBA -MaxParallelActions=4`, `taskset -c 0-11`, and no `prlimit`. Log:
  `Saved/Linux/l164/ue-build-final.log`. The initial attempt exposed an incorrect RDG texture registration overload;
  it had already compiled `VoxelForgeLivingPlaneModule.cpp` and the generated module code. The corrected final
  build passed.
 - The host `PluginDeps/VoxelForge/Source` and `.uplugin` links were temporarily pointed at this worktree for the
  build and restored to `/home/jahni/VoxelM/Plugins/VoxelForge` afterward. The temporary shader link was removed.
 - Standalone build, final repeatability comparison, checksum-mismatch negative control, plugin JSON parse, and
  `git diff --check` passed.
 - Not run: fast generation verification (generation sources are untouched), Intel GPU checksum comparison, or a UE
  editor render/shader-runtime check. The Linux UBT build verifies C++ and module integration, not first-use shader
  compilation or material appearance.
 New Unreal source and shader files for the owner's Windows build:
 - `Source/VoxelForgeLivingPlane/VoxelForgeLivingPlane.Build.cs`
 - `Source/VoxelForgeLivingPlane/Public/VoxelForgeLivingPlaneActor.h`
 - `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneActor.cpp`
 - `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneModule.cpp`
 - `Shaders/LivingPlane.usf`
 No VoxelForge generation module files changed. Remaining risks are the Intel checksum confirmation and first-use UE
 shader/material rendering, which require the owner's GPU/editor run.
@@ -0,0 +1,55 @@
 # Living Plane in Unreal Engine 5.7
 `VoxelForgeLivingPlane` is a separate runtime module. It does not call the VoxelForge terrain generators and it does not read the simulated texture back to the CPU. The actor owns two transient `RGBA32f` render targets and advances them with an RDG compute pass. The CPU sends object state and fixed-step uniforms only.
 ## Add it to a level
 1. Enable the VoxelForge plugin and restart the editor so the `VoxelForgeLivingPlane` runtime module and its shader mapping load.
 2. Create a material named `M_LivingPlane` using the graph below.
 3. Place `VoxelForgeLivingPlaneActor` in the level. Assign `M_LivingPlane` to **Plane Material**.
 4. Keep the actor on the world XY plane with unit actor scale. `Plane Length Meters` controls the mesh width and simulation width; the built-in plane mesh is scaled to that size.
 5. The actor creates and clears its two GPU state targets on `BeginPlay`. The mesh has collision disabled; this surface is render-only and does not change VoxelForge density or collision queries.
 ## Material graph
 Use a Surface, Opaque material. The actor binds these parameters on its dynamic material instance:
 - `LivingField`: Texture Object Parameter. The texture is the current RGBA32f simulation state; **R** is displacement in metres.
 - `PlaneLengthMeters`: Scalar Parameter.
 - `FieldSize`: Scalar Parameter, equal to the render target width and height.
 For World Position Offset:
 1. Read `LivingField` at `TextureCoordinate[0]` with a Texture Sample.
 2. Multiply its **R** output by `100` to convert metres to Unreal centimetres.
 3. Append `(0, 0)` to that value, making `(0, 0, heightCm)`, and connect it to **World Position Offset**.
 For the displaced normal, sample the height at four UV offsets using the same texture object:
 - Left/right UV: `TexCoord + (-1/FieldSize, 0)` and `TexCoord + (1/FieldSize, 0)`.
 - Down/up UV: `TexCoord + (0, -1/FieldSize)` and `TexCoord + (0, 1/FieldSize)`.
 - `dHdx = (Right.R - Left.R) * FieldSize / (2 * PlaneLengthMeters)`.
 - `dHdy = (Up.R - Down.R) * FieldSize / (2 * PlaneLengthMeters)`.
 - Make and normalize the tangent-space vector `(-dHdx, -dHdy, 1)`, then connect it to **Normal**.
 The built-in plane's U/V tangent directions align with local X/Y. Use a neutral base colour and roughness around `0.7` to start. The graph assumes a horizontal plane; add a local-to-world transform if the plane needs arbitrary rotation.
 ## Drive objects
 `ObjectInputs` has two slots. Each `FVFLivingPlaneObjectInput` contains world position in centimetres, world velocity in centimetres per second, radius in centimetres, base push acceleration in metres per second squared, and an active flag. Blueprint can use **Set Object State** or set the array entry; C++ can call the same method. Set the object's center about one radius above the plane while it contacts it, and mark the slot inactive after lift-off.
 The compute shader uses the radius to scale the Gaussian contact footprint. The original wave equation keeps the L163 wave speed, damping, foundation spring, travelling breathing force, and recovering imprint. The base push acceleration supplies the object force; lateral speed adds `0.25 m/s²` per `1 m/s`, and downward speed adds `0.5 m/s²` per `1 m/s`. Upward velocity does not add force. Object positions and velocities are transformed into the plane's local frame and converted from centimetres to metres before upload.
 Each step uses `dt = 1.30 / sqrt(8*c*c/(dx*dx) + foundationStiffness)`, with `dx = PlaneLengthMeters / FieldSize`. Simulation time passed to breathing is the fixed step index times `dt`. Game-thread delta time only determines how many fixed steps are queued; no GPU field data is read back in the normal path.
 ## Build files
 The owner's Windows build needs every added source and shader file:
 - `Source/VoxelForgeLivingPlane/VoxelForgeLivingPlane.Build.cs`
 - `Source/VoxelForgeLivingPlane/Public/VoxelForgeLivingPlaneActor.h`
 - `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneActor.cpp`
 - `Source/VoxelForgeLivingPlane/Private/VoxelForgeLivingPlaneModule.cpp`
 - `Shaders/LivingPlane.usf`
 The `VoxelForge.uplugin` runtime-module entry must ship with them.
@@ -0,0 +1,33 @@
 # Unreal mapping note
 The prototype stores height, vertical velocity, a recovering imprint, and a spare
 channel in a pair of `RGBA32F` textures. A world-owned Unreal component can keep
 equivalent transient render graph textures and advance them with a compute pass. It
 should own simulation time and clear or restore its buffers when the world is recreated.
 The sphere path becomes a world-space interaction event: position, contact radius,
 and impulse strength are supplied to the compute pass. For multiplayer or deterministic
 replay, replicate the compact events and simulation tick, or record the resulting field;
 do not assume that independent GPU floating-point runs will produce byte-identical
 textures.
 The rendered top surface can remain a render-only displaced mesh. If it must participate
 in voxel collision or queries, its height must also reach the density evaluator. For a
 height `h(x,y)`, the plugin's density convention is negative inside solid and positive
 in air, so the plane's signed density is `z - h(x,y)`. Keep this calculation in metres
 until the existing voxel/Core boundary converts with the active voxel size (25 cm by
 default); do not mix metre distances and voxel counts in the wave solver.
 The current sample is an isolated visual field. Wiring this into `AVoxelWorld` would
 need an explicit owner for simulation lifetime, collision/update cadence, save/load,
 and the replication policy before it could affect shipped terrain.
 ## L164 render-only Unreal implementation
 `Source/VoxelForgeLivingPlane/` now implements this render-only path as a separate
 runtime module. `AVoxelForgeLivingPlaneActor` owns two UAV-capable RGBA32F render
 targets, advances the wave, breathing, and imprint equations with an RDG global shader,
 and binds the current texture to its plane material. Blueprint/C++ supplies object
 position, radius, velocity, push, and active state. The actor does not call the
 generation modules and does not read the field back. Level setup and the material graph
 are in [UE-SETUP.md](UE-SETUP.md).
@@ -0,0 +1,22 @@
 #!/usr/bin/env bash
 set -euo pipefail
 SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 PLUGIN_ROOT="$(cd -- "${SCRIPT_DIR}/../.." && pwd)"
 OUTPUT_DIR="${PLUGIN_ROOT}/Saved/Linux/l164"
 CXX="${CXX:-g++}"
 command -v "${CXX}" >/dev/null || { echo "C++ compiler not found: ${CXX}" >&2; exit 2; }
 pkg-config --exists egl gl libpng || {
    echo "EGL, desktop OpenGL, and libpng development files are required" >&2
    exit 2
 }
 mkdir -p "${OUTPUT_DIR}"
 read -r -a GRAPHICS_FLAGS <<<"$(pkg-config --cflags --libs egl gl libpng)"
 taskset -c 0-11 prlimit --as=6442450944 -- \
    "${CXX}" -std=c++20 -O2 -g -Wall -Wextra -Wpedantic \
    "${SCRIPT_DIR}/LivingPlane.cpp" -o "${OUTPUT_DIR}/living-plane" \
    "${GRAPHICS_FLAGS[@]}"
 echo "built ${OUTPUT_DIR}/living-plane"
@@ -0,0 +1,132 @@
 #!/usr/bin/env python3
 """Compare final field checksums across different query and capture settings."""
 from __future__ import annotations
 import argparse
 import json
 import pathlib
 import shutil
 import subprocess
 import sys
 PLUGIN_ROOT = pathlib.Path(__file__).resolve().parents[2]
 def read_checksum(path: pathlib.Path) -> str:
    try:
        with path.open(encoding="utf-8") as source:
            result = json.load(source)
    except (OSError, json.JSONDecodeError) as error:
        raise RuntimeError(f"could not read {path}: {error}") from error
    checksum = result.get("field_checksum_fnv1a64")
    if not isinstance(checksum, str) or len(checksum) != 16:
        raise RuntimeError(f"{path} has no 16-digit field checksum")
    return checksum
 def compare(left: pathlib.Path, right: pathlib.Path) -> bool:
    left_checksum = read_checksum(left)
    right_checksum = read_checksum(right)
    if left_checksum != right_checksum:
        print(
            "FAIL field checksum mismatch: "
            f"{left}={left_checksum}, {right}={right_checksum}",
            file=sys.stderr,
        )
        return False
    print(f"PASS field checksum matches: {left_checksum}")
    return True
 def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--binary",
        type=pathlib.Path,
        default=PLUGIN_ROOT / "Saved/Linux/l164/living-plane",
    )
    parser.add_argument(
        "--out",
        type=pathlib.Path,
        default=PLUGIN_ROOT / "Saved/Linux/l164/repeatability",
    )
    parser.add_argument("--device", choices=("auto", "cpu", "gpu"), default="cpu")
    parser.add_argument("--size", type=int, default=512)
    parser.add_argument("--steps", type=int, default=1800)
    parser.add_argument(
        "--compare-only",
        nargs=2,
        type=pathlib.Path,
        metavar=("LEFT_JSON", "RIGHT_JSON"),
        help="compare existing timing.json files; used to exercise the failure path",
    )
    options = parser.parse_args()
    if options.compare_only:
        return 0 if compare(*options.compare_only) else 1
    if not options.binary.is_file():
        parser.error(f"binary not found: {options.binary}; run Experiments/LivingPlane/build.sh")
    options.out.mkdir(parents=True, exist_ok=True)
    off_dir = options.out / "queries-off_capture-off"
    on_dir = options.out / "queries-on_capture-every-900"
    for directory in (off_dir, on_dir):
        if directory.exists():
            shutil.rmtree(directory)
    common = [
        f"--device={options.device}",
        "--scene=alive",
        f"--size={options.size}",
        f"--steps={options.steps}",
    ]
    runs = (
        ("--capture-every=0", "--queries=off", off_dir),
        ("--capture-every=900", "--queries=on", on_dir),
    )
    for capture, queries, output in runs:
        command = [
            "taskset",
            "-c",
            "0-11",
            "prlimit",
            "--as=6442450944",
            "--",
            "timeout",
            "1740s",
            str(options.binary.resolve()),
            *common,
            capture,
            queries,
            f"--out={output}",
        ]
        print("RUN " + " ".join(command), flush=True)
        log_path = options.out / f"{output.name}.log"
        with log_path.open("w", encoding="utf-8") as log_file:
            try:
                subprocess.run(
                    command,
                    cwd=PLUGIN_ROOT,
                    check=True,
                    stdout=log_file,
                    stderr=subprocess.STDOUT,
                )
            except subprocess.CalledProcessError:
                print(log_path.read_text(encoding="utf-8"), file=sys.stderr)
                raise
        print(log_path.read_text(encoding="utf-8").rstrip())
    left = off_dir / "timing.json"
    right = on_dir / "timing.json"
    return 0 if compare(left, right) else 1
 if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
        print(f"FAIL repeatability check: {error}", file=sys.stderr)
        raise SystemExit(1)
@@ -0,0 +1,85 @@
 Texture2D<float4> SourceState;
 RWTexture2D<float4> TargetState;
 int2 GridSize;
 float Dt;
 float Dx;
 float PlaneLength;
 float WaveSpeed;
 float Damping;
 float FoundationStiffness;
 float TimeSeconds;
 float2 BreathingSettings;
 float4 ImprintSettings;
 float4 ObjectPositionRadius[2];
 float4 ObjectVelocityPush[2];
 [numthreads(8, 8, 1)]
 void MainCS(uint3 DispatchThreadId : SV_DispatchThreadID)
 {
 	int2 Pixel = int2(DispatchThreadId.xy);
 	if (Pixel.x >= GridSize.x || Pixel.y >= GridSize.y)
 	{
 		return;
 	}
 	int2 Lo = int2(0, 0);
 	int2 Hi = GridSize - 1;
 	float4 State = SourceState.Load(int3(Pixel, 0));
 	float Height = State.r;
 	float Velocity = State.g;
 	float Imprint = State.b;
 	float Left = SourceState.Load(int3(max(Pixel + int2(-1, 0), Lo), 0)).r;
 	float Right = SourceState.Load(int3(min(Pixel + int2(1, 0), Hi), 0)).r;
 	float Down = SourceState.Load(int3(max(Pixel + int2(0, -1), Lo), 0)).r;
 	float Up = SourceState.Load(int3(min(Pixel + int2(0, 1), Hi), 0)).r;
 	float Laplacian = (Left + Right + Down + Up - 4.0 * Height) / max(Dx * Dx, 1.0e-8);
 	float2 World = (float2(Pixel) + 0.5) * Dx - PlaneLength * 0.5;
 	float Interaction = 0.0;
 	float Contact = 0.0;
 	for (int ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
 	{
 		float4 PositionRadius = ObjectPositionRadius[ObjectIndex];
 		if (PositionRadius.w <= 0.0)
 		{
 			continue;
 		}
 		float4 VelocityPush = ObjectVelocityPush[ObjectIndex];
 		float Radius = PositionRadius.w;
 		float Sigma = max(Radius * (0.58 / 0.43), Dx);
 		float2 Offset = World - PositionRadius.xy;
 		float Weight = exp(-dot(Offset, Offset) / max(2.0 * Sigma * Sigma, 1.0e-8));
 		float HeightAboveContact = max(PositionRadius.z - Radius, 0.0);
 		float ContactHeight = 1.0 - smoothstep(0.0, max(Radius, Dx), HeightAboveContact);
 		float ImpactSpeed = length(VelocityPush.xy) * 0.25 + max(-VelocityPush.z, 0.0) * 0.5;
 		float Push = max(VelocityPush.w, 0.0) + ImpactSpeed;
 		Interaction -= Push * Weight * ContactHeight;
 		if (Push > 0.0)
 		{
 			Contact = max(Contact, Weight * ContactHeight);
 		}
 	}
 	float Breathing = 0.0;
 	if (BreathingSettings.x != 0.0)
 	{
 		float Swell = sin(World.x * 0.48 - TimeSeconds * 0.22)
 			* cos(World.y * 0.42 + TimeSeconds * 0.16);
 		Breathing = BreathingSettings.y * Swell * sin(TimeSeconds * 0.48);
 	}
 	float NextImprint = Imprint;
 	if (ImprintSettings.x != 0.0)
 	{
 		NextImprint = clamp(Imprint * exp(-Dt / max(ImprintSettings.z, 1.0e-4))
 			- Contact * ImprintSettings.y * Dt, -ImprintSettings.w, 0.0);
 	}
 	float FoundationTarget = ImprintSettings.x != 0.0 ? Imprint : 0.0;
 	float Acceleration = WaveSpeed * WaveSpeed * Laplacian
 		- FoundationStiffness * (Height - FoundationTarget) + Interaction + Breathing;
 	float NextVelocity = (Velocity + Acceleration * Dt) * exp(-Damping * Dt);
 	float NextHeight = Height + NextVelocity * Dt;
 	TargetState[Pixel] = float4(NextHeight, NextVelocity, NextImprint, 0.0);
 }
@@ -0,0 +1,303 @@
 #include "VoxelForgeLivingPlaneActor.h"
 #include "Engine/TextureRenderTarget2D.h"
 #include "Engine/TextureRenderTarget.h"
 #include "Engine/StaticMesh.h"
 #include "Engine/World.h"
 #include "Materials/MaterialInstanceDynamic.h"
 #include "Materials/MaterialInterface.h"
 #include "RenderGraphBuilder.h"
 #include "RenderGraphUtils.h"
 #include "RHICommandList.h"
 #include "RHIResources.h"
 #include "DataDrivenShaderPlatformInfo.h"
 #include "GlobalShader.h"
 #include "ShaderParameterStruct.h"
 #include "UObject/ConstructorHelpers.h"
 #include "Components/StaticMeshComponent.h"
 namespace
 {
 	constexpr int32 LivingPlaneThreadGroupSize = 8;
 	struct FLivingPlaneStepInput
 	{
 		FVector4f ObjectPositionRadius[2] = {FVector4f(0, 0, 0, -1), FVector4f(0, 0, 0, -1)};
 		FVector4f ObjectVelocityPush[2] = {FVector4f(0, 0, 0, 0), FVector4f(0, 0, 0, 0)};
 		float TimeSeconds = 0.0f;
 	};
 	class FVFLivingPlaneStepCS final : public FGlobalShader
 	{
 		DECLARE_GLOBAL_SHADER(FVFLivingPlaneStepCS);
 		SHADER_USE_PARAMETER_STRUCT(FVFLivingPlaneStepCS, FGlobalShader);
 		BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
 			SHADER_PARAMETER(FIntPoint, GridSize)
 			SHADER_PARAMETER(float, Dt)
 			SHADER_PARAMETER(float, Dx)
 			SHADER_PARAMETER(float, PlaneLength)
 			SHADER_PARAMETER(float, WaveSpeed)
 			SHADER_PARAMETER(float, Damping)
 			SHADER_PARAMETER(float, FoundationStiffness)
 			SHADER_PARAMETER(float, TimeSeconds)
 			SHADER_PARAMETER(FVector2f, BreathingSettings)
 			SHADER_PARAMETER(FVector4f, ImprintSettings)
 			SHADER_PARAMETER_ARRAY(FVector4f, ObjectPositionRadius, [2])
 			SHADER_PARAMETER_ARRAY(FVector4f, ObjectVelocityPush, [2])
 			SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D<float4>, SourceState)
 			SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D<float4>, TargetState)
 		END_SHADER_PARAMETER_STRUCT()
 	public:
 		static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
 		{
 			return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
 		}
 	};
 	IMPLEMENT_GLOBAL_SHADER(FVFLivingPlaneStepCS,
 		"/Plugin/VoxelForgeLivingPlane/LivingPlane.usf", "MainCS", SF_Compute)
 	UTextureRenderTarget2D* CreateFieldTarget(UObject* Outer, int32 Size, FName Name)
 	{
 		UTextureRenderTarget2D* Target = NewObject<UTextureRenderTarget2D>(Outer, Name, RF_Transient);
 		Target->RenderTargetFormat = RTF_RGBA32f;
 		Target->bCanCreateUAV = true;
 		Target->bAutoGenerateMips = false;
 		Target->ClearColor = FLinearColor::Transparent;
 		Target->Filter = TF_Bilinear;
 		Target->AddressX = TA_Clamp;
 		Target->AddressY = TA_Clamp;
 		Target->InitAutoFormat(Size, Size);
 		Target->UpdateResourceImmediate(true);
 		return Target;
 	}
 }
 AVoxelForgeLivingPlaneActor::AVoxelForgeLivingPlaneActor()
 {
 	PrimaryActorTick.bCanEverTick = true;
 	PlaneMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LivingPlaneMesh"));
 	SetRootComponent(PlaneMesh);
 	PlaneMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
 	PlaneMesh->SetMobility(EComponentMobility::Movable);
 	static ConstructorHelpers::FObjectFinder<UStaticMesh> PlaneAsset(
 		TEXT("/Engine/BasicShapes/Plane.Plane"));
 	if (PlaneAsset.Succeeded())
 	{
 		PlaneMesh->SetStaticMesh(PlaneAsset.Object);
 	}
 	ObjectInputs.SetNum(2);
 }
 void AVoxelForgeLivingPlaneActor::OnConstruction(const FTransform& Transform)
 {
 	Super::OnConstruction(Transform);
 	if (PlaneMesh)
 	{
 		// /Engine/BasicShapes/Plane is 100 cm square; one Unreal scale unit
 		// therefore corresponds to one metre of authored plane length.
 		PlaneMesh->SetRelativeScale3D(FVector(PlaneLengthMeters, PlaneLengthMeters, 1.0));
 	}
 }
 float AVoxelForgeLivingPlaneActor::GetStableStepSeconds() const
 {
 	const float Dx = PlaneLengthMeters / static_cast<float>(FMath::Max(GridSize, 16));
 	const float EigenFrequencySquared = 8.0f * WaveSpeedMetersPerSecond * WaveSpeedMetersPerSecond
 		/ FMath::Max(Dx * Dx, 1.0e-8f) + FoundationStiffnessPerSecondSquared;
 	return 1.30f / FMath::Sqrt(FMath::Max(EigenFrequencySquared, 1.0e-8f));
 }
 void AVoxelForgeLivingPlaneActor::BeginPlay()
 {
 	Super::BeginPlay();
 	GridSize = FMath::Clamp(GridSize, 16, 2048);
 	PlaneLengthMeters = FMath::Max(PlaneLengthMeters, 1.0f);
 	FixedStepSeconds = GetStableStepSeconds();
 	CreateFieldTargets();
 	if (PlaneMaterial && PlaneMesh)
 	{
 		DynamicPlaneMaterial = PlaneMesh->CreateDynamicMaterialInstance(0, PlaneMaterial);
 		if (DynamicPlaneMaterial)
 		{
 			DynamicPlaneMaterial->SetScalarParameterValue(TEXT("PlaneLengthMeters"), PlaneLengthMeters);
 			DynamicPlaneMaterial->SetScalarParameterValue(TEXT("FieldSize"), static_cast<float>(GridSize));
 		}
 	}
 	UpdateMaterialField();
 }
 void AVoxelForgeLivingPlaneActor::CreateFieldTargets()
 {
 	FieldTargets[0] = CreateFieldTarget(this, GridSize, TEXT("LivingPlaneStateA"));
 	FieldTargets[1] = CreateFieldTarget(this, GridSize, TEXT("LivingPlaneStateB"));
 	CurrentFieldIndex = 0;
 	SimulationStepCount = 0;
 	SimulationAccumulatorSeconds = 0.0;
 }
 void AVoxelForgeLivingPlaneActor::SetObjectState(int32 ObjectIndex,
 	const FVFLivingPlaneObjectInput& State)
 {
 	if (!ObjectInputs.IsValidIndex(ObjectIndex) || ObjectIndex >= 2)
 	{
 		return;
 	}
 	ObjectInputs[ObjectIndex] = State;
 }
 void AVoxelForgeLivingPlaneActor::ResetSimulation()
 {
 	if (!IsInGameThread() || !FieldTargets[0] || !FieldTargets[1])
 	{
 		return;
 	}
 	CreateFieldTargets();
 	FixedStepSeconds = GetStableStepSeconds();
 	UpdateMaterialField();
 }
 void AVoxelForgeLivingPlaneActor::UpdateMaterialField()
 {
 	if (DynamicPlaneMaterial && FieldTargets[CurrentFieldIndex])
 	{
 		DynamicPlaneMaterial->SetTextureParameterValue(TEXT("LivingField"), FieldTargets[CurrentFieldIndex]);
 	}
 }
 void AVoxelForgeLivingPlaneActor::EnqueueSimulationSteps(int32 NumSteps)
 {
 	if (NumSteps <= 0 || !FieldTargets[0] || !FieldTargets[1])
 	{
 		return;
 	}
 	FTextureRenderTargetResource* ResourceA = FieldTargets[0]->GameThread_GetRenderTargetResource();
 	FTextureRenderTargetResource* ResourceB = FieldTargets[1]->GameThread_GetRenderTargetResource();
 	if (!ResourceA || !ResourceB)
 	{
 		return;
 	}
 	TArray<FLivingPlaneStepInput> Steps;
 	Steps.Reserve(NumSteps);
 	const FTransform PlaneTransform = GetActorTransform();
 	for (int32 Step = 0; Step < NumSteps; ++Step)
 	{
 		FLivingPlaneStepInput& Input = Steps.AddDefaulted_GetRef();
 		Input.TimeSeconds = static_cast<float>(SimulationStepCount + Step) * FixedStepSeconds;
 		for (int32 ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
 		{
 			if (!ObjectInputs.IsValidIndex(ObjectIndex) || !ObjectInputs[ObjectIndex].bActive)
 			{
 				continue;
 			}
 			const FVFLivingPlaneObjectInput& Object = ObjectInputs[ObjectIndex];
 			const FVector LocalPosition = PlaneTransform.InverseTransformPosition(Object.WorldPositionCm);
 			const FVector LocalVelocity = PlaneTransform.InverseTransformVector(Object.WorldVelocityCmPerSecond);
 			const float RadiusMeters = FMath::Max(Object.RadiusCm * 0.01f, 0.001f);
 			Input.ObjectPositionRadius[ObjectIndex] = FVector4f(
 				static_cast<float>(LocalPosition.X * 0.01),
 				static_cast<float>(LocalPosition.Y * 0.01),
 				static_cast<float>(LocalPosition.Z * 0.01),
 				RadiusMeters);
 			Input.ObjectVelocityPush[ObjectIndex] = FVector4f(
 				static_cast<float>(LocalVelocity.X * 0.01),
 				static_cast<float>(LocalVelocity.Y * 0.01),
 				static_cast<float>(LocalVelocity.Z * 0.01),
 				FMath::Max(Object.PushAccelerationMetersPerSecondSquared, 0.0f));
 		}
 	}
 	const int32 Resolution = GridSize;
 	const int32 InitialFieldIndex = CurrentFieldIndex;
 	const float Dt = static_cast<float>(FixedStepSeconds);
 	const float Dx = PlaneLengthMeters / static_cast<float>(Resolution);
 	const float PlaneLength = PlaneLengthMeters;
 	const float WaveSpeed = WaveSpeedMetersPerSecond;
 	const float Damping = DampingPerSecond;
 	const float Foundation = FoundationStiffnessPerSecondSquared;
 	const float BreathingStrength = bEnableBreathing ? BreathingStrengthMetersPerSecondSquared : 0.0f;
 	const FVector2f BreathingSettings(bEnableBreathing ? 1.0f : 0.0f, BreathingStrength);
 	const FVector4f ImprintSettings(bEnableImprint ? 1.0f : 0.0f,
 		ImprintCaptureMetersPerSecond, FMath::Max(ImprintRecoverySeconds, 1.0e-4f),
 		FMath::Max(ImprintMaxDepthMeters, 0.0f));
 	ENQUEUE_RENDER_COMMAND(VoxelForgeLivingPlaneStep)(
 		[ResourceA, ResourceB, Steps = MoveTemp(Steps), InitialFieldIndex, Resolution, Dt, Dx, PlaneLength,
 			WaveSpeed, Damping, Foundation, BreathingSettings, ImprintSettings]
 		(FRHICommandListImmediate& RHICmdList) mutable
 		{
 			FRDGBuilder GraphBuilder(RHICmdList, RDG_EVENT_NAME("VoxelForgeLivingPlane"));
 			FRDGTextureRef Fields[2] = {
 			RegisterExternalTexture(GraphBuilder, ResourceA->GetRenderTargetTexture().GetReference(), TEXT("LivingPlaneStateA")),
 			RegisterExternalTexture(GraphBuilder, ResourceB->GetRenderTargetTexture().GetReference(), TEXT("LivingPlaneStateB"))};
 			TShaderMapRef<FVFLivingPlaneStepCS> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel));
 			int32 CurrentIndex = InitialFieldIndex;
 			for (const FLivingPlaneStepInput& StepInput : Steps)
 			{
 				const int32 TargetIndex = 1 - CurrentIndex;
 				FVFLivingPlaneStepCS::FParameters* PassParameters =
 					GraphBuilder.AllocParameters<FVFLivingPlaneStepCS::FParameters>();
 				PassParameters->GridSize = FIntPoint(Resolution, Resolution);
 				PassParameters->Dt = Dt;
 				PassParameters->Dx = Dx;
 				PassParameters->PlaneLength = PlaneLength;
 				PassParameters->WaveSpeed = WaveSpeed;
 				PassParameters->Damping = Damping;
 				PassParameters->FoundationStiffness = Foundation;
 				PassParameters->TimeSeconds = StepInput.TimeSeconds;
 				PassParameters->BreathingSettings = BreathingSettings;
 				PassParameters->ImprintSettings = ImprintSettings;
 				for (int32 ObjectIndex = 0; ObjectIndex < 2; ++ObjectIndex)
 				{
 					PassParameters->ObjectPositionRadius[ObjectIndex] = StepInput.ObjectPositionRadius[ObjectIndex];
 					PassParameters->ObjectVelocityPush[ObjectIndex] = StepInput.ObjectVelocityPush[ObjectIndex];
 				}
 				PassParameters->SourceState = GraphBuilder.CreateSRV(Fields[CurrentIndex]);
 				PassParameters->TargetState = GraphBuilder.CreateUAV(Fields[TargetIndex]);
 				FComputeShaderUtils::AddPass(GraphBuilder,
 					RDG_EVENT_NAME("LivingPlaneStep"),
 					ComputeShader, PassParameters,
 					FIntVector(FMath::DivideAndRoundUp(Resolution, LivingPlaneThreadGroupSize),
 						FMath::DivideAndRoundUp(Resolution, LivingPlaneThreadGroupSize), 1));
 				CurrentIndex = TargetIndex;
 			}
 			GraphBuilder.Execute();
 		});
 	CurrentFieldIndex = (InitialFieldIndex + NumSteps) & 1;
 	SimulationStepCount += NumSteps;
 	UpdateMaterialField();
 }
 void AVoxelForgeLivingPlaneActor::Tick(float DeltaSeconds)
 {
 	Super::Tick(DeltaSeconds);
 	if (FixedStepSeconds <= 0.0 || !FieldTargets[0] || !FieldTargets[1])
 	{
 		return;
 	}
 	SimulationAccumulatorSeconds += FMath::Max(static_cast<double>(DeltaSeconds), 0.0);
 	const int32 StepsToRun = FMath::Min(
 		static_cast<int32>(SimulationAccumulatorSeconds / FixedStepSeconds), 32);
 	if (StepsToRun > 0)
 	{
 		SimulationAccumulatorSeconds -= StepsToRun * FixedStepSeconds;
 		EnqueueSimulationSteps(StepsToRun);
 	}
 }
 void AVoxelForgeLivingPlaneActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
 {
 	Super::EndPlay(EndPlayReason);
 	DynamicPlaneMaterial = nullptr;
 	FieldTargets[0] = nullptr;
 	FieldTargets[1] = nullptr;
 }
@@ -0,0 +1,25 @@
 #include "Modules/ModuleManager.h"
 #include "Interfaces/IPluginManager.h"
 #include "Misc/Paths.h"
 #include "ShaderCore.h"
 class FVoxelForgeLivingPlaneModule final : public IModuleInterface
 {
 public:
 	virtual void StartupModule() override
 	{
 		const TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(TEXT("VoxelForge"));
 		if (!Plugin.IsValid())
 		{
 			UE_LOG(LogTemp, Error, TEXT("VoxelForgeLivingPlane could not find its owning plugin."));
 			return;
 		}
 		AddShaderSourceDirectoryMapping(
 			TEXT("/Plugin/VoxelForgeLivingPlane"),
 			FPaths::Combine(Plugin->GetBaseDir(), TEXT("Shaders")));
 	}
 };
 IMPLEMENT_MODULE(FVoxelForgeLivingPlaneModule, VoxelForgeLivingPlane)
@@ -0,0 +1,114 @@
 #pragma once
 #include "CoreMinimal.h"
 #include "GameFramework/Actor.h"
 #include "VoxelForgeLivingPlaneActor.generated.h"
 class UMaterialInterface;
 class UMaterialInstanceDynamic;
 class UStaticMeshComponent;
 class UTextureRenderTarget2D;
 USTRUCT(BlueprintType)
 struct FVFLivingPlaneObjectInput
 {
 	GENERATED_BODY()
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
 	FVector WorldPositionCm = FVector(0.0, 0.0, 43.0);
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
 	FVector WorldVelocityCmPerSecond = FVector::ZeroVector;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object", meta=(ClampMin="0.1"))
 	float RadiusCm = 43.0f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object", meta=(ClampMin="0.0"))
 	float PushAccelerationMetersPerSecondSquared = 36.0f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
 	bool bActive = false;
 };
 /** A render-only, GPU-stepped heightfield plane. Object state is uploaded; the field is never read back. */
 UCLASS(BlueprintType, Blueprintable)
 class VOXELFORGELIVINGPLANE_API AVoxelForgeLivingPlaneActor : public AActor
 {
 	GENERATED_BODY()
 public:
 	AVoxelForgeLivingPlaneActor();
 	virtual void BeginPlay() override;
 	virtual void Tick(float DeltaSeconds) override;
 	virtual void OnConstruction(const FTransform& Transform) override;
 	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 	UFUNCTION(BlueprintCallable, Category="Living Plane|Object")
 	void SetObjectState(int32 ObjectIndex, const FVFLivingPlaneObjectInput& State);
 	UFUNCTION(BlueprintCallable, Category="Living Plane")
 	void ResetSimulation();
 	UFUNCTION(BlueprintPure, Category="Living Plane")
 	int64 GetSimulationStepCount() const { return SimulationStepCount; }
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Living Plane")
 	TObjectPtr<UStaticMeshComponent> PlaneMesh;
 	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Living Plane|Rendering")
 	TObjectPtr<UMaterialInterface> PlaneMaterial;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="16", ClampMax="2048"))
 	int32 GridSize = 256;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="1.0", ClampMax="100.0"))
 	float PlaneLengthMeters = 12.0f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
 	float WaveSpeedMetersPerSecond = 4.5f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
 	float DampingPerSecond = 1.35f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0"))
 	float FoundationStiffnessPerSecondSquared = 28.0f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation")
 	bool bEnableBreathing = true;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Simulation", meta=(ClampMin="0.0", ClampMax="30.0"))
 	float BreathingStrengthMetersPerSecondSquared = 4.8f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint")
 	bool bEnableImprint = true;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.0", ClampMax="1.0"))
 	float ImprintCaptureMetersPerSecond = 0.15f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.1", ClampMax="60.0"))
 	float ImprintRecoverySeconds = 6.0f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Imprint", meta=(ClampMin="0.0", ClampMax="1.0"))
 	float ImprintMaxDepthMeters = 0.34f;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Living Plane|Object")
 	TArray<FVFLivingPlaneObjectInput> ObjectInputs;
 private:
 	void CreateFieldTargets();
 	void EnqueueSimulationSteps(int32 NumSteps);
 	void UpdateMaterialField();
 	float GetStableStepSeconds() const;
 	UPROPERTY(Transient)
 	TObjectPtr<UTextureRenderTarget2D> FieldTargets[2];
 	UPROPERTY(Transient)
 	TObjectPtr<UMaterialInstanceDynamic> DynamicPlaneMaterial;
 	int32 CurrentFieldIndex = 0;
 	int64 SimulationStepCount = 0;
 	double SimulationAccumulatorSeconds = 0.0;
 	double FixedStepSeconds = 0.0;
 };
@@ -0,0 +1,28 @@
 using UnrealBuildTool;
 public class VoxelForgeLivingPlane : ModuleRules
 {
 	public VoxelForgeLivingPlane(ReadOnlyTargetRules Target) : base(Target)
 	{
 		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
 		if (Target.Platform == UnrealTargetPlatform.Linux)
 		{
 			bUseUnity = false;
 		}
 		PublicDependencyModuleNames.AddRange(new string[]
 		{
 			"Core",
 			"CoreUObject",
 			"Engine"
 		});
 		PrivateDependencyModuleNames.AddRange(new string[]
 		{
 			"Projects",
 			"RenderCore",
 			"RHI"
 		});
 	}
 }
@@ -33,48 +33,22 @@
 #include <variant>
 #include <vector>
-// L88-only composition split. These switches let the timing harness remove passage work and
+static bool VF_IsDiagnosticEnvSwitchEnabled(const char* Name)
 // resolved boundary-band work independently. They are diagnostic only, never world settings.
 static bool VF_IsL88DiagnosticSwitchEnabled(const char* Name)
 {
    const char* Value=std::getenv(Name);
    return Value&&Value[0]=='1'&&Value[1]=='\0';
 }
 static bool VF_IsL88PassageCompositionDisabled()
 {
    static const bool bDisabled=VF_IsL88DiagnosticSwitchEnabled(
        "VOXELFORGE_L88_DISABLE_PASSAGES")
        ||VF_IsL88DiagnosticSwitchEnabled("VOXELFORGE_L86_DISABLE_PASSAGE_COMPOSITION");
    return bDisabled;
 }
 static bool VF_IsL88BoundaryBandsDisabled()
 {
    static const bool bDisabled=VF_IsL88DiagnosticSwitchEnabled(
        "VOXELFORGE_L88_DISABLE_BOUNDARY_BANDS")
        ||VF_IsL88DiagnosticSwitchEnabled("VOXELFORGE_L86_DISABLE_PASSAGE_COMPOSITION");
    return bDisabled;
 }
 static bool VF_IsL88AllowPassageAblationWalkabilityFailure()
 {
    static const bool bEnabled=VF_IsL88DiagnosticSwitchEnabled(
        "VOXELFORGE_L88_ALLOW_PASSAGE_ABLATION_WALKABILITY_FAILURE");
    return bEnabled;
 }
 static bool VF_IsL98PassagePrepareTraceEnabled()
 {
-    static const bool bEnabled=VF_IsL88DiagnosticSwitchEnabled(
+    static const bool bEnabled=VF_IsDiagnosticEnvSwitchEnabled(
        "VOXELFORGE_L98_PASSAGE_PREP_TRACE");
    return bEnabled;
 }
 static bool VF_IsL130PassageReachProofAuditEnabled()
 {
-    static const bool bEnabled=VF_IsL88DiagnosticSwitchEnabled(
+    static const bool bEnabled=VF_IsDiagnosticEnvSwitchEnabled(
        "VOXELFORGE_L130_PASSAGE_REACH_PROOF_AUDIT");
    return bEnabled;
 }
@@ -327,18 +301,14 @@ public:
        {
            mayContainResolvedBoundaryBand_=shape.ResolvedBoundaryBandsIntersectSubvoxelRange(
                minimumSubvoxels_[2],maximumSubvoxels_[2]);
-            const bool disablePassageComposition=VF_IsL88PassageCompositionDisabled();
+            mayContainTransitionPassageFade_=shape.ResolvedTransitionPassageFadeIntersectsTileXY(
-            if(VF_IsL88BoundaryBandsDisabled())mayContainResolvedBoundaryBand_=false;
+                minimumSubvoxels_,maximumSubvoxels_);
-            mayContainTransitionPassageFade_=!disablePassageComposition
+            featureIndices_=shape.BuildPassageFeatureTileList(
-                &&shape.ResolvedTransitionPassageFadeIntersectsTileXY(
+                minimumSubvoxels_,maximumSubvoxels_);
                    minimumSubvoxels_,maximumSubvoxels_);
            if(!disablePassageComposition)
                featureIndices_=shape.BuildPassageFeatureTileList(
                    minimumSubvoxels_,maximumSubvoxels_);
            stampIndices_=shape.BuildStampTileList(minimumSubvoxels_,maximumSubvoxels_);
            cavernFeatureIndices_=shape.BuildCavernFeatureTileList(
                minimumSubvoxels_,maximumSubvoxels_);
-            passageRoutes_.assign(shape.ResolvedLayout&&!disablePassageComposition
+            passageRoutes_.assign(shape.ResolvedLayout
                ?shape.ResolvedLayout->passages.size():0,0);
            passageRouteSegments_.resize(passageRoutes_.size());
            for(const std::uint32_t featureIndex:featureIndices_)
@@ -1561,12 +1531,8 @@ public:
        // the generic stratum transition distance creates a discontinuity at a
        // mouth that crosses a wide transition band. Keep that opt-in field whole;
        // its host-rock value already supplies the ceiling and bedrock.
        const bool disablePassageComposition=!nativeLattice
            &&VF_IsL88PassageCompositionDisabled();
        const bool disableBoundaryBands=!nativeLattice
            &&VF_IsL88BoundaryBandsDisabled();
        float boundary=graphDensity;
-        if(!nativeLattice&&!disableBoundaryBands)
+        if(!nativeLattice)
        {
            VoxelForgeCore::Linux77Profiler::FScopedPhase l77BandsPhase(
                VoxelForgeCore::Linux77Profiler::EPhase::Bands);
@@ -1595,7 +1561,6 @@ public:
                ?bound->Resolved->passageCapabilities.hasNativeCaveField
                :bound->Resolved->passageCapabilities.hasNativeLatticeField))
        {
            if(!disablePassageComposition)
            {
                VoxelForgeCore::Linux77Profiler::FScopedPhase l77PassagePhase(
                    VoxelForgeCore::Linux77Profiler::EPhase::Passage);
@@ -1626,7 +1591,6 @@ public:
                ELegacyFieldTerm::ComposerPassage);
            final=ApplyResolvedCavernFloorCaps(stamped,X,Y,Z);
        }
        if(!disablePassageComposition)
        {
            VoxelForgeCore::Linux77Profiler::FScopedPhase l77PassagePhase(
                VoxelForgeCore::Linux77Profiler::EPhase::Passage);
@@ -2332,18 +2296,8 @@ public:
        const bool bPassageRoutesValid=!bValidatePassageRoutes||ValidatePassageRoutes();
        if(!bPassageRoutesValid)
        {
-            if(VF_IsL88PassageCompositionDisabled()
+            Error="compiled shape world contains a solid passage centreline sample";
-                &&!VF_IsL88BoundaryBandsDisabled()
+            return false;
                &&VF_IsL88AllowPassageAblationWalkabilityFailure())
            {
                std::printf("[L88PassageAblation] route walkability failed as expected; "
                    "continuing only to measure passage-off/bands-on readiness\n");
            }
            else
            {
                Error="compiled shape world contains a solid passage centreline sample";
                return false;
            }
        }
        Stats.PassageValidationSeconds=std::chrono::duration<double>(Clock::now()-Substage).count();
        Built=true;
@@ -0,0 +1,37 @@
 # VoxelForge — open read-only review: what should be done and focused on now?
 You are an outside reviewer. **Do not edit, create or delete any file, and do not build or run anything.** Read the
 repository and its reports and reason. Be thorough; mark each claim as [CODE] (with file:line), [MEASURED] (from a
 report), or [INFERENCE].
 ## The project, in the owner's words and goals
 - VoxelForge is a UE5 density-field voxel plugin for a **multiplayer** game. The world is made of stacked "strates"
  (layers) linked by tunnels. The standalone C++ generator is "Core" (`Standalone/Core`), and it is also compiled into
  Unreal. Read `CLAUDE.md`, `CODEMAP.md`, `ARCHITECTURE.md`, `GDD.md`, `COMPOSER-NOTES.md` and `fable-idea.md` at the
  plugin root for the game and design intent. The research reports are in
  `Standalone/Research/WorldAssemblerM3/Linux*/REPORT.md` and the `Astra*/` reviews.
 - Owner goals stated over time:
  - the near terrain (LOD0–2) ready in ~1 s on arrival, then far terrain keeps filling in at low priority;
  - same seed gives the same world on every machine (byte-identity with older versions is NOT required);
  - smooth for VR and high-speed travel;
  - all generators (surface, floating islands, caves, dreamcore/liminal, etc.) working in Core;
  - the system should eventually *invent* strates and worlds from tagged authored content plus a seed;
  - keep things simple and avoid over-complication.
 - The current main line is branch `assembler/world`.
 ## Your task
 Look at the whole: code, reports, design docs, and the direction of the last few dozen rounds. Tell the owner what
 should be done and focused on now, whatever it is. That may be performance, features, generation quality, gameplay
 foundations, architecture, technical debt, tooling, process, or stopping something. Don't assume the recent focus is
 the right one; question it if the evidence says so.
 Answer:
 1. **Where the project actually is**: what works, what's fragile, what's missing for the game to exist.
 2. **The top 3–5 things to focus on now**, ranked, each with why, a rough size, what "done" looks like, and how to
   tell it worked.
 3. **What to stop or deprioritise**, and why.
 4. **Risks or debts** that will bite later if ignored.
 Write plain Markdown, at most ~1,500 words, readable by a non-specialist owner (explain jargon briefly).
@@ -0,0 +1,72 @@
 [INFERENCE] **Focus now on a small, persistent multiplayer descent, supported by end-to-end Unreal performance work.** VoxelForge has substantial terrain technology. The larger uncertainty is whether it delivers a reliable, interesting shared expedition. Another sequence of tunnel optimizations will not resolve that.
 Read-only review of `assembler/world` at `044cd6d`; no files changed and no builds, tests, or project execution. [CODE] identifies repository evidence; design-document references establish intent, not implementation. [MEASURED] means reported results, not independently reproduced measurements.
 **1. Where the project actually is**
 [CODE] **Core is real and integrated, but generator implementation remains mixed.** Unreal compiles the canonical standalone sources through validated wrappers. Core dispatches to surface, floating-island and native graph evaluators, with a legacy-generator fallback when appropriate. That is useful coverage, but does not mean every family has a complete native implementation. See [VoxelForgeCore.Build.cs:15](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForgeCore/VoxelForgeCore.Build.cs:15) and [ShapeWorldInternal.h:600](/home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:600).
 [MEASURED] **Passage correctness and speed have improved substantially.** L109 simplified tunnels and removed support-restoration machinery, reducing floating-island and tunnel-network near-generation times by approximately 31–38%. L125 reports 21,425/21,425 open route samples, a maximum sampled floor offset of 7.884 mm, and matching cross-compiler/worker hashes. These are meaningful engineering achievements. [L109](Standalone/Research/WorldAssemblerM3/Linux109/REPORT.md), [L125](Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md).
 [MEASURED] **The one-second player experience is not achieved.** L125’s standalone near-ready medians were approximately 0.78–1.03 seconds. L127’s Unreal startup took 2.22–2.51 seconds; at 30 m/s, median near coverage fell from 43.36% to 40.22% after the smooth-tunnel merge. Both versions recovered after stopping. L130 found no measurable timing improvement and skipped Unreal movement. These are different workloads; subtracting their times would not isolate a particular overhead. [L125](Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md), [L127](Standalone/Research/WorldAssemblerM3/Linux127/REPORT.md), [L130](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
 [CODE] **Multiplayer foundations exist; the multiplayer lifecycle remains unfinished here.** There are season hashes, local terrain-edit entry points, and streaming-anchor infrastructure. The architecture explicitly leaves join replication, authoritative edit messages, late-join snapshots and networked season changes open. The edit entry point directly dispatches to local modification paths. [VoxelWorld.h:574](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelWorld.h:574), [VoxelWorld.cpp:15771](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelWorld.cpp:15771), [ARCHITECTURE.md:2408](/home/jahni/VoxelM/Plugins/VoxelForge/ARCHITECTURE.md:2408).
 [CODE] **The composer is more than a proposal, but less than the full content vision.** It rolls candidates, measures them and rejects failures. The intended system additionally combines tagged geometry, materials, decorations, creatures and audio; theme coherence remains an open design item. [VoxelSeasonManifest.cpp:2523](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelSeasonManifest.cpp:2523), [COMPOSER-NOTES.md:1512](/home/jahni/VoxelM/Plugins/VoxelForge/COMPOSER-NOTES.md:1512).
 [INFERENCE] **This repository demonstrates a capable terrain platform, not yet a validated game loop.** I cannot establish what gameplay exists outside the plugin. The GDD itself identifies “Is the descent fun?” as its first unresolved question. [GDD.md:441](/home/jahni/VoxelM/Plugins/VoxelForge/GDD.md:441).
 **2. Ranked priorities**
 All sizes below are [INFERENCE]: rough focused engineering estimates, excluding substantial art production.
 **1 — Deliver one multiplayer expedition that survives reconnecting. Size: 3–6 weeks.**
 [INFERENCE] Use two contrasting strates and their connecting tunnel. Two players descend, find one destination, uncover or collect something, return, and retain their changes after restart. Include a third player joining after terrain has changed. Avoid expanding immediately into the city economy or community backend.
 [INFERENCE] The necessary foundation is a server-approved world identity, ordered authoritative edits, a saved snapshot plus subsequent edits, and collision around separated players. Give edits stable identifiers so retransmission cannot apply them twice. Reuse the existing local edit and anchor systems.
 [INFERENCE] **Done:** host/client edits agree; a late joiner reconstructs the same terrain; restart preserves it; incompatible world versions fail clearly; remote players have ground when away from the host.
 [INFERENCE] **Success:** a complete shared expedition without terrain disagreement, lost progress or collision failures—and players can explain what made them want to descend again. This tests the project’s central assumptions much earlier than a complete RPG would.
 **2 — Close the Unreal arrival and movement gap. Size: 1–3 weeks initially.**
 [MEASURED] L122 found idle generation capacity while admission was blocked; L123 measured approximately 19 ms from region request to game-thread observation despite sub-millisecond median compilation. Simple lookahead and admission relaxations failed their combined coverage/frame-time gates. L121’s modest extra far-apply lane did improve far coverage. [L121](Standalone/Research/WorldAssemblerM3/Linux121/REPORT.md), [L122](Standalone/Research/WorldAssemblerM3/Linux122/REPORT.md), [L123](Standalone/Research/WorldAssemblerM3/Linux123/REPORT.md).
 [INFERENCE] First establish one current-build, rendered Unreal baseline on intended hardware. Measure arrival through **visible terrain and usable collision**, then walking, 30 m/s travel, turns, teleporting and edits. Record near coverage, far gaps, frame-time spikes and memory separately. NullRHI measurements, which omit rendering, cannot certify VR comfort.
 [INFERENCE] Investigate region completion, admission and publication before another broad density rewrite. A game-thread continuation is a candidate experiment, not a proven solution; keep world mutation on its owning thread.
 [INFERENCE] **Done:** approximately one-second LOD0–2 readiness on the agreed hardware, safe collision, steadily filling far terrain, and an explicit movement-coverage target without worsening frame spikes. **Success:** repeated rendered runs meet those limits, including with remote-player collision work. Do not redefine “ready” as only the nearest handful of tiles.
 **3 — Turn generator breadth into playable variety. Size: 2–4 weeks for the first content slice.**
 [INFERENCE] Establish a compact capability matrix for each family: Core dispatch, entrances/exits, interior connectivity, edits, materials/content, far terrain and performance. Include dreamcore/liminal explicitly; motif generation alone does not establish a convincing anomalous place.
 [MEASURED] L58 illustrates the distinction: its lattice route passed reachability checks, but the review described a corkscrew tunnel rather than the intended open vertical shaft. Technical validity and identity are separate acceptance criteria. [L58](Standalone/Research/WorldAssemblerM3/Linux58/REPORT.md).
 [INFERENCE] Extend the existing offline composer with a small tagged library: a grounded cave, an island environment and one liminal identity, each with coherent materials, sound and a destination. Preserve owner review before publishing a season.
 [INFERENCE] **Done:** several seeds produce recognizably different, coherent places with findable progression and usable encounter spaces. **Success:** players navigate them without developer guidance and distinguish their identities without reading labels. Expand families after this works.
 **4 — Consolidate the evidence and remove obsolete complexity incrementally. Size: 2–4 days, then ongoing.**
 [INFERENCE] Maintain one short current-state page: shipped behavior, open defects, active baseline, hardware and next acceptance test. Keep historical reports as history. Remove rejected experimental paths when they no longer serve a specific comparison; extract stable responsibilities when touching oversized files.
 [INFERENCE] **Done:** a contributor can identify the current evaluator, runtime path, multiplayer gaps and performance limits without reconstructing 130 rounds. **Success:** new work no longer repeats rejected experiments or treats old measurements as current.
 **3. Stop or deprioritise**
 - [INFERENCE] **Pause open-ended tunnel micro-optimization.** L125/L126 missed the older speed bar; L130’s reach correction produced no measurable speedup. Keep correctness fixes, but require a current cost account and a bounded experiment before further optimization. [MEASURED: L126](Standalone/Research/WorldAssemblerM3/Linux126/REPORT.md), [L130](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
 - [INFERENCE] **Do not implement Astra recommendations mechanically.** Astra1’s support-heavy model predates L109’s simplification. Astra2/3 offer hypotheses, not measured wins for today’s code. Re-profile before adopting them.
 - [INFERENCE] **Defer GPU generation, a mesher replacement, elaborate discovery systems and large-scale backend work.** None currently resolves the missing shared expedition.
 - [INFERENCE] **Stop requiring old-version byte identity for deliberate generation changes.** Preserve peer agreement within a version and explicit versioned saves; permit reviewed geometry improvements.
 **4. Debts that will bite later**
 [INFERENCE] **Determinism needs a deployment contract.** Linux Clang/GCC and worker-count agreement is strong evidence, not proof across every intended machine. Include Windows/compiler/CPU combinations actually supported. World identity must cover evaluator, content, layout, scale and edit state—not merely seed. [MEASURED: L130](Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md).
 [CODE] **Scale and fallback complexity remain active integration risks.** Core is opt-in, and runtime queries bridge different coordinate conventions. [VoxelWorld.h:300](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelWorld.h:300), [VoxelWorld.cpp:15612](/home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelWorld.cpp:15612). [INFERENCE] Test edits, content placement and collision across those boundaries before broadening authoring.
 [INFERENCE] **A passing route audit does not prove a whole strate is enjoyable, connected or suitable for six-player combat.** Retain geometric checks, but add actual traversal, destination discovery and encounter-space evaluation. Those are now more valuable than another polished tunnel benchmark.
@@ -0,0 +1,50 @@
 # Linux131 — current state and dead experiment cleanup
 Branch `wip/l131-current-state`, based on `cbbfd46`; Core evaluator remains v227. The root [`CURRENT-STATE.md`](../../../../CURRENT-STATE.md) consolidates the shipping behavior, current references, verification commands, open gaps, and closed proposals.
 ## Removed
 - Removed `VOXELFORGE_L86_DISABLE_PASSAGE_COMPOSITION`, `VOXELFORGE_L88_DISABLE_PASSAGES`, `VOXELFORGE_L88_DISABLE_BOUNDARY_BANDS`, and `VOXELFORGE_L88_ALLOW_PASSAGE_ABLATION_WALKABILITY_FAILURE`. These only supported archived passage/boundary ablations in `Linux86/RunL86Ceiling.py`, `Linux87/RunL87Timeline.py`, and `Linux88/RunL88CeilingSplit.py`; no current `verify.py` gate or live comparison uses them. Passage feature selection, passage composition, and boundary bands now run on the normal path, and passage-route validation cannot be waived by the old ablation flag.
 - Removed the `VOXELFORGE_AUDIT_LEGACY_ROUTE_GRADE` block from `Standalone/Source/WorldAssemblyPrototype.h`. The source contained its only reference; no test, current tool, or report invoked it.
 - Kept route-candidate grading and all user-visible behavior. This cleanup adds no evaluator version or baseline change.
 ## Switch and hook inventory
 ### Environment switches in compiled Core/Source
 | Switch | Effect and consumer | Keep decision |
 |---|---|---|
 | `VOXELFORGE_L74_TIGHT_PROOF_CONTROL` | Proof negative control. `Linux74/FalsifierL74.py` and `Linux75/FalsifierL75.py`. | Keep for falsifier reproducibility; not a current fast-tier input. |
 | `VOXELFORGE_L75_TN_BLOCK_REGRESSION` | Fixed TunnelNetwork regression path in Core and mesher. `RunTnBlockRegressionL75.py` and `FalsifierL75.py`. | Keep; the regression tools still consume it. |
 | `VOXELFORGE_L98_PASSAGE_PREP_TRACE` | Emits preparation-stage timing/count data. `RunL98Hashes.py` and `RunL98ReuseCounts.py`. | Keep as a focused profiler for future preparation comparisons. |
 | `VOXELFORGE_L98_PASSAGE_REUSE_PROBE` | Compares the prepared projection with direct scalar queries. `RunL98ReuseCounts.py`. | Keep for exactness probes. |
 | `VOXELFORGE_L104_FAR_HIT_CACHE` | Selects indexed versus linear far-hit candidate lookup. `RunL104ReadinessPairs.py` and `RunL104ProbeStats.py`. | Keep for reproducible A/B comparisons; cache defaults on. |
 | `VOXELFORGE_L104_FAR_HIT_STATS` | Emits far-hit candidate/query counters. `RunL104ProbeStats.py`. | Keep for the measurement tool. |
 | `VOXELFORGE_L115_DENSITY_PROFILE` | Enables density and floor-query profiling. `RunL115DensityProbe.py`, `RunL119DensityProbe.py`, and `RunL125DensityProbe.py`. | Keep; these remain the focused floor-probe path. |
 | `VOXELFORGE_L130_PASSAGE_REACH_PROOF_AUDIT` | Checks passage proof/feature influence bounds. L130's reach audit and report. | Keep for reach changes and audit reproduction. |
 Archived runners also set `VOXELFORGE_L81_PASSAGE_BOUND_PADDING_VOXELS`, `VOXELFORGE_L86_PASSAGE_RESULT_CACHE`, `VOXELFORGE_L90_PASSAGE_BRICK_METRES`, `VOXELFORGE_L90_PASSAGE_CANDIDATE_CENSUS`, `VOXELFORGE_L90_PASSAGE_REACH_METRES`, `VOXELFORGE_L91_PASSAGE_SOURCE_FLOOR_VOXELS`, `VOXELFORGE_L93_PASSAGE_CARVE_REACH_METRES`, `VOXELFORGE_L98_PASSAGE_REUSE_COUNTS`, `VOXELFORGE_L114_DENSITY_PROFILE`, and `VOXELFORGE_L118_TAG_TIMING`. None has a compiled-source reader at `cbbfd46`; they are inert historical runner strings.
 ### Other experiments, diagnostics, and legacy paths retained
 - **World-changing tunnel ablations:** all 14 `voxel.TunnelAblate*` controls remain (`CaveWarp`, `DetailOps`, `RoomSDF`, `TunnelSDF`, `TunnelCore`, `PassageCarving`, `PassageStructuralPosts`, `NativeFloor`, `Disturbances`, `OriginSpine`, `BoundarySeal`, `LandingPosts`, `XYEdgeSeal`, `PitChimneySDF`). The editor commandlet writes their resolved mask into export and result manifests; the archived `PERF-SAMPLED.md` and `WORK-NEXT.md` record their measurements. No current runner invokes an ablation. Keep for manifest attribution and historical reproduction; removing it needs a metadata migration. Source: [`VoxelDensityAblation.cpp`](../../../../Source/VoxelForge/Private/VoxelDensityAblation.cpp), [`VoxelForgeExploreCommandlet.cpp`](../../../../Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp).
 - **Research fields:** `voxel.ResearchRedefinedDensityField`, `voxel.ResearchRedefinedDensityDetailScale`, `voxel.ResearchParameterizedCave`, and `voxel.ResearchParameterizedCaveSet` are default-off and used by `Tools/VoxelForgeTest.ps1` steps 2d/2e/2f. The region-eval commandlet consumes `SetResearchBrickBinningEnabled`, `SetResearchBrickRoomReachScale`, and `SetResearchRegionCacheWindowEnabled`; keep these editor-only experiment paths. Source: [`VoxelForgeRegionEvalExperiment.cpp`](../../../../Source/VoxelForgeEditor/Private/VoxelForgeRegionEvalExperiment.cpp), [`VoxelForgeTest.ps1`](../../../../Tools/VoxelForgeTest.ps1).
 - **Runtime profiling and trace:** `voxel.SampleStacks` still starts `FVoxelStackSampler` (the guarded `Tools/VoxelForgeTest.ps1 -SampleDensityStacks` path consumes it); `voxel.ProfileDensity`, `voxel.ProfileDensityFull`, `voxel.ProfileTileGeneration`, `voxel.ProfileCollisionCookStages`, and `voxel.PerfAttribution` remain opt-in. `voxel.StartupTraceFile`, `voxel.StartupTraceMaxTiles`, and `voxel.StartupTraceUntilEndPlay` feed the Unreal startup trace used by the arrival/movement runners. Keep. Build-time `VOXELFORGE_PROFILE_LEGACY_TERMS` (L76) and `VOXELFORGE_PROFILE_L77`/`--linux77-profile` (stack sampler and route census) remain in `Standalone/BuildLinux.sh` and Core.
 - **Standalone profiles and timelines:** retained `--profile-column-overlap`, `--profile-lod-work`, `--profile-passage-composer`, `--instrument-tile-drain`, `--cold-worker-timeline`, `--linux77-profile`, `--tls-probe=N`, `--tls-probe-touch=...`, and `--diagnostic-slow-shape-compile-ms=N`. The viewer's `--profile-attribution`, `--profile-detail-band`, and `--profile-far-column-overlap` remain. The L77 profiler, tile drain instrumentation, timelines, and TLS probe are measurement hooks; archived reports and runners still provide reproducible consumers.
 - **Standalone audits:** all source-advertised hooks remain: `--audit-ore-vein-yield`, `--audit-resolved-layout-boundaries`, `--audit-strate-transitions`, `--audit-resolved-layout-passages`, `--audit-heightfield-profile`, `--audit-motif-intervals`, `--audit-landmark-reachability`, `--audit-native-caves`, `--audit-native-lattice`, `--audit-surface-clearance`, `--audit-uniform-block-proofs`, `--audit-base-page-equivalence`, `--audit-route-parity`, `--audit-passage-tile-seams`, `--audit-passage-source-clamp`, `--audit-passage-carve-reach`, `--audit-tile-shape-readiness`, and the mesher's `--audit-raw-skirts`. `verify.py fast` consumes the current route, passage, block-proof, transition, native-field and negative-control subset; dedicated L37/L75/L125/L130 runners exercise the specialized audits. Keep the whole audit set.
 - **Evaluator A/B controls:** `voxel.FastIsFinite`, `voxel.UseFusedEvaluator`, `voxel.WormBlockSkip`, `voxel.TileCacheWindow` / its two minimum-LOD controls, `voxel.SpatialIndex`, `voxel.ChunkRoutingCache`, `voxel.UseOperatorBlock`, `voxel.CoreColumnCacheDirectMapped`, `voxel.CoreMCGradientMemoization`, `voxel.FloorRound1PassageProjectionCache`, `voxel.PlayerFitMemo`, `voxel.UseBlockEarlyOut`, `voxel.OuterClassifierMode`, and `voxel.SealedSolidProof` remain. They select optimized or comparison paths; the density block equivalence test explicitly forces `UseFusedEvaluator=0`, while most others are production defaults or historical measurement controls. `voxel.WormsForceOff` is a world-changing development measurement override. Kept; no current L131 gate changes them.
 - **Standalone A/B and geometry controls:** `--exact-midpoint-density-memo`, `--no-exact-midpoint-density-memo`, `--active-lane-batching`, `--proof-block-cells=N`, `--parallel-sign-edge-repair`, `--serial-sign-edge-repair`, and `--shape-helper-limit=8|12` remain. The L94 report documents serial edge repair; no current `verify.py` consumer was found for the other CLI A/B controls, so they remain pending a separately reviewed removal. `voxel.TilePostReachDebug`, `voxel.TilePostReachScale`, and `voxel.TileReachCostDiagnostics` remain for the tile-post-reach test; `voxel.TunnelMouthTrim` remains a development-only room-mouth geometry control. No L131 gate uses these.
 - `FLegacyGeneratorFieldAdapter` remains the Core fallback for unsupported generator/recipe combinations, and Unreal's Core switch remains default-off. `voxel.StreamingLegacyPendingResultCap=1` remains the L120–L123 admission negative control; `voxel.StreamingCoarseFirst` remains opt-in pending a rendered owner-plan check. `bStandaloneResearchRoundTunnels` and `bStandaloneResearchEnhancedWalls` remain consumed by the standalone viewer/Core adapter.
 ## Checks
 - Clang 19 and GCC standalone builds passed with the L131 source stamp `5119cee164406856cbca496d160c0e0a8124ae2529fa7c0ebd51634a7c65a6cb`. `Standalone/BuildLinux.sh` applied the required CPU and address-space limits.
 - L80 timing: one warm-up per binary and five interleaved pairs in each of four strata × W8/W12 cells, comparing the pre-cleanup L130 binary with L131. Load was 0.81; CPU idle was 99.2%. Across 40 pairs per metric, mean relative change was −0.22% near-ready (95% CI −1.02% to +0.57%) and −0.29% whole-view (−1.04% to +0.46%); the intervals include zero. [Raw timing summary](../../../../Saved/Linux/l131/timing/summary.json).
 - Exact hashes: **24/24** owner4 SW/FI/TN/VS × Clang/GCC × W1/W8/W12 tile and whole-view identities; **18/18** canonical cases across owner4 SurfaceWorld and owner2 SurfaceWorld/FloatingIslands. All match the pre-cleanup L130 binary and agree across compiler/worker combinations. For transparency, forcing the owner4 dataset through `--recipe=floating-islands` exited during setup with “could not find a finite SurfaceWorld strate”, before hashing; it is not a valid canonical case. [Tile matrix](../../../../Saved/Linux/l131/hash-matrix/summary.json), [canonical matrix](../../../../Saved/Linux/l131/canonical-matrix/summary.json).
 - Walkability: **21,425/21,425** passage centerline samples open. Seam audit: **4 pairs / 4,900** shared samples, zero mismatches. [Audit log](../../../../Saved/Linux/l131/seam-audit.log).
 - Fast tier: **PASS**, 259 gated checks plus 5 diagnostics, 80 runs, 371.0 s. The five diagnostic-only comparisons are historical baselines; all required checks pass. [Summary](../../../../Saved/Linux/l131/fast-summary.json).
 - Linux `VFHostEditor`: **PASS**, 27/27 actions, 78.81 s with `-NoUBA -MaxParallelActions=4`, no `prlimit`. UBT's default log rotation first failed before compilation in the read-only user config directory; the successful rerun set `-Log=.../Saved/Linux/l131/ubt.log`. Three existing RealtimeMesh deprecation warnings remain. [Build log](../../../../Saved/Linux/l131/ue-build.log).
 - Unreal `Source/` files changed: **none**. No Windows compile is requested by this diff; Windows determinism remains unverified.
 - `git diff --check` passes. No commit, push, or stash was made.
 Builds, per-run logs, timing records, hash records, and audit output are under `Saved/Linux/l131/`.
@@ -0,0 +1,75 @@
 #!/usr/bin/env python3
 """Compare 18 canonical owner4/owner2 hashes with the pre-cleanup L130 binary."""
 from __future__ import annotations
 import json
 import re
 import subprocess
 import time
 from pathlib import Path
 ROOT = Path(__file__).resolve().parents[4]
 OUT = ROOT / "Saved/Linux/l131/canonical-matrix"
 DATASETS = {
    "owner4": ROOT / "Standalone/data/owner_world.json",
    "owner2": ROOT / "Standalone/data/regression/owner_world_2strate_l61.json",
 }
 RECIPES = {"owner4": ("surface-world",), "owner2": ("surface-world", "floating-islands")}
 BINARIES = {
    "base": ROOT / "Saved/Linux/l130/bin/VoxelForgeCoreHeadless-l130-{compiler}",
    "l131": ROOT / "Saved/Linux/l131/bin/VoxelForgeCoreHeadless-l131-{compiler}",
 }
 HASH_RE = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
 def run(dataset: str, recipe: str, compiler: str, workers: int, version: str) -> tuple[list[str], float]:
    binary = Path(str(BINARIES[version]).format(compiler=compiler))
    label = f"{dataset}-{recipe}-{compiler}-w{workers}-{version}"
    log = OUT / f"{label}.log"
    command = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
        "timeout", "1740s", str(binary), str(DATASETS[dataset]),
        "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
        "--force-generate", f"--workers={workers}", "--clip-radius=3",
        "--max-clip-level=8", "--max-level=8", f"--recipe={recipe}", "--stream-hash"]
    started = time.monotonic()
    with log.open("w", encoding="utf-8") as stream:
        process = subprocess.run(command, cwd=ROOT, stdout=stream,
            stderr=subprocess.STDOUT, check=False, timeout=1740)
    hashes = HASH_RE.findall(log.read_text(encoding="utf-8", errors="replace"))
    if process.returncode or len(hashes) != 12:
        raise RuntimeError(f"hash run failed: {log}; exit={process.returncode}; rows={len(hashes)}")
    return hashes, time.monotonic() - started
 def main() -> int:
    OUT.mkdir(parents=True, exist_ok=True)
    rows = []
    groups = {}
    for dataset, recipes in RECIPES.items():
        for recipe in recipes:
            signatures = []
            for workers in (1, 8, 12):
                for compiler in ("clang", "gcc"):
                    before, before_s = run(dataset, recipe, compiler, workers, "base")
                    after, after_s = run(dataset, recipe, compiler, workers, "l131")
                    row = {"dataset": dataset, "recipe": recipe, "compiler": compiler,
                        "workers": workers, "hash_mismatches": sum(a != b for a, b in zip(before, after)),
                        "rows": len(after), "base_s": round(before_s, 3), "l131_s": round(after_s, 3),
                        "base_log": f"Saved/Linux/l131/canonical-matrix/{dataset}-{recipe}-{compiler}-w{workers}-base.log",
                        "l131_log": f"Saved/Linux/l131/canonical-matrix/{dataset}-{recipe}-{compiler}-w{workers}-l131.log"}
                    rows.append(row)
                    signatures.append((compiler, workers, after))
                    print("[L131CanonicalHash] " + json.dumps(row, sort_keys=True), flush=True)
                    (OUT / "runs-partial.json").write_text(json.dumps(rows, indent=2) + "\n")
            first = signatures[0][2]
            stable = all(sig == first for _, _, sig in signatures)
            groups[f"{dataset}/{recipe}"] = {"base_equals_l131": all(row["hash_mismatches"] == 0 for row in rows if row["dataset"] == dataset and row["recipe"] == recipe),
                "all_clang_gcc_workers_agree": stable}
    failures = [row for row in rows if row["hash_mismatches"]]
    (OUT / "summary.json").write_text(json.dumps({"runs": rows, "groups": groups,
        "passed": len(rows)-len(failures), "failed": len(failures)}, indent=2) + "\n")
    return 1 if failures or not all(group["all_clang_gcc_workers_agree"] for group in groups.values()) else 0
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -0,0 +1,84 @@
 #!/usr/bin/env python3
 """Compare 24 owner4 tile-hash cases with the pre-cleanup L130 binary."""
 from __future__ import annotations
 import json
 import re
 import subprocess
 import time
 from pathlib import Path
 ROOT = Path(__file__).resolve().parents[4]
 OUT = ROOT / "Saved/Linux/l131/hash-matrix"
 DATA = ROOT / "Standalone/data/owner_world.json"
 BINARIES = {
    "base": ROOT / "Saved/Linux/l130/bin/VoxelForgeCoreHeadless-l130-{compiler}",
    "l131": ROOT / "Saved/Linux/l131/bin/VoxelForgeCoreHeadless-l131-{compiler}",
 }
 CAMERAS = {
    "sw": ((8.0, 16.0, -372.2626953125), 2850),
    "fi": ((25.8369140625, 3.19921875, -737.0), 2249),
    "tn": ((19.166015625, -14.2001953125, -753.3740234375), 2233),
    "vs": ((-20.0625, -5.068359375, -900.353515625), 2329),
 }
 TILE_RE = re.compile(
    r"^\[PipelineTileHash\] lod=(-?\d+) x=(-?\d+) y=(-?\d+) z=(-?\d+) "
    r"density=(0x[0-9a-f]+) mesh=(0x[0-9a-f]+) payload=(0x[0-9a-f]+) "
    r"topology=(0x[0-9a-f]+)$", re.M)
 WHOLE_RE = re.compile(
    r"^\[PipelineWholeViewHash\] tiles=(\d+) density=(0x[0-9a-f]+) "
    r"mesh=(0x[0-9a-f]+) payload=(0x[0-9a-f]+) topology=(0x[0-9a-f]+)$", re.M)
 def capture(camera_name: str, compiler: str, workers: int, version: str) -> tuple[dict, tuple[str, ...], float]:
    camera, expected_tiles = CAMERAS[camera_name]
    camera_arg = ",".join(f"{value:.12f}" for value in camera) + ",0,0"
    binary = Path(str(BINARIES[version]).format(compiler=compiler))
    log = OUT / f"owner4-{camera_name}-{compiler}-w{workers}-{version}.log"
    command = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
        "timeout", "1740s", str(binary), str(DATA), "--world-assembler-prototype",
        "--stream-benchmark", "--stream-pipeline", f"--workers={workers}",
        "--clip-radius=3", "--max-clip-level=8", "--max-level=8",
        f"--camera={camera_arg}", "--stream-hash-tiles"]
    started = time.monotonic()
    with log.open("w", encoding="utf-8") as stream:
        result = subprocess.run(command, cwd=ROOT, stdout=stream,
            stderr=subprocess.STDOUT, check=False, timeout=1740)
    elapsed = time.monotonic() - started
    output = log.read_text(encoding="utf-8", errors="replace")
    tiles = {(int(match.group(1)), int(match.group(2)), int(match.group(3)), int(match.group(4))):
             match.group(5, 6, 7, 8) for match in TILE_RE.finditer(output)}
    whole = WHOLE_RE.search(output)
    if result.returncode or whole is None or len(tiles) != expected_tiles or len(tiles) != int(whole.group(1)):
        raise RuntimeError(f"incomplete {version} {camera_name}/{compiler}/W{workers}: {log}")
    return tiles, whole.groups(), elapsed
 def main() -> int:
    OUT.mkdir(parents=True, exist_ok=True)
    rows = []
    for camera_name in CAMERAS:
        for compiler in ("clang", "gcc"):
            for workers in (1, 8, 12):
                old_tiles, old_whole, old_s = capture(camera_name, compiler, workers, "base")
                new_tiles, new_whole, new_s = capture(camera_name, compiler, workers, "l131")
                keys = set(old_tiles) | set(new_tiles)
                tile_mismatches = sum(old_tiles.get(key) != new_tiles.get(key) for key in keys)
                row = {"owner": "owner4", "camera": camera_name, "compiler": compiler,
                    "workers": workers, "tiles": len(new_tiles),
                    "tile_mismatches": tile_mismatches,
                    "whole_view_match": old_whole == new_whole,
                    "base_s": round(old_s, 3), "l131_s": round(new_s, 3),
                    "base_log": f"Saved/Linux/l131/hash-matrix/owner4-{camera_name}-{compiler}-w{workers}-base.log",
                    "l131_log": f"Saved/Linux/l131/hash-matrix/owner4-{camera_name}-{compiler}-w{workers}-l131.log"}
                rows.append(row)
                print("[L131HashIdentity] " + json.dumps(row, sort_keys=True), flush=True)
                (OUT / "runs-partial.json").write_text(json.dumps(rows, indent=2) + "\n")
    failures = [row for row in rows if row["tile_mismatches"] or not row["whole_view_match"]]
    (OUT / "summary.json").write_text(json.dumps({"runs": rows, "passed": len(rows)-len(failures),
        "failed": len(failures)}, indent=2) + "\n")
    return 1 if failures else 0
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -0,0 +1,115 @@
 #!/usr/bin/env python3
 """Five interleaved L80 readiness measurements per stratum and worker count."""
 from __future__ import annotations
 import json
 import os
 import re
 import statistics
 import subprocess
 import time
 from pathlib import Path
 ROOT = Path(__file__).resolve().parents[4]
 OUT = ROOT / "Saved/Linux/l131/timing"
 DATA = ROOT / "Standalone/data/owner_world.json"
 BINARIES = {
    "base": ROOT / "Saved/Linux/l130/bin/VoxelForgeCoreHeadless-l130-clang",
    "l131": ROOT / "Saved/Linux/l131/bin/VoxelForgeCoreHeadless-l131-clang",
 }
 CAMERAS = {
    0: (8.0, 16.0, -372.2626953125),
    1: (25.8369140625, 3.19921875, -737.0),
    2: (19.166015625, -14.2001953125, -753.3740234375),
    3: (-20.0625, -5.068359375, -900.353515625),
 }
 PIPELINE_RE = re.compile(r"^\[StreamPipeline\] (.*)$", re.M)
 FIELDS_RE = re.compile(r"([a-zA-Z0-9_]+)=([^ ]+)")
 NEAR_RE = re.compile(r"^\[WorldAssemblerNearLODReady\] lods=0-2 tiles=(\d+)/(\d+) cold_ready_s=([0-9.]+)$", re.M)
 def run(strate: int, workers: int, version: str, phase: str, replicate: int) -> dict:
    camera = ",".join(f"{value:.12f}" for value in CAMERAS[strate]) + ",0,0"
    label = f"s{strate}-w{workers}-{version}-{phase}{replicate}-l131-v227"
    log = OUT / f"{label}.log"
    command = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
        "timeout", "1740s", str(BINARIES[version]), str(DATA),
        "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
        f"--workers={workers}", "--clip-radius=3", "--max-clip-level=8",
        "--max-level=8", f"--camera={camera}", "--profile-lod-work",
        "--stream-scheduler-policy=3"]
    started = time.monotonic()
    with log.open("w", encoding="utf-8") as output:
        result = subprocess.run(command, cwd=ROOT, stdout=output,
            stderr=subprocess.STDOUT, check=False, timeout=1740)
    content = log.read_text(encoding="utf-8", errors="replace")
    pipeline, near = PIPELINE_RE.search(content), NEAR_RE.search(content)
    if result.returncode or pipeline is None or near is None:
        raise RuntimeError(f"timing run failed: {log}; exit={result.returncode}")
    fields = dict(FIELDS_RE.findall(pipeline.group(1)))
    row = {"strate": strate, "workers": workers, "version": version,
        "phase": phase, "replicate": replicate,
        "lod02_ready_s": float(near.group(3)),
        "whole_view_ready_s": float(fields["whole_view_ready"].removesuffix("s")),
        "wall_s": round(time.monotonic() - started, 3),
        "log": str(log.relative_to(ROOT))}
    print("[L131TimingRun] " + json.dumps(row, sort_keys=True), flush=True)
    return row
 def quiet_machine() -> tuple[float, float]:
    load_1m = os.getloadavg()[0]
    def totals() -> tuple[int, int]:
        fields = Path("/proc/stat").read_text().splitlines()[0].split()
        values = [int(value) for value in fields[1:]]
        return sum(values), values[3] + (values[4] if len(values) > 4 else 0)
    before = totals()
    time.sleep(2.0)
    after = totals()
    idle = 100.0 * (after[1] - before[1]) / max(1, after[0] - before[0])
    return load_1m, idle
 def main() -> int:
    if any(not path.is_file() for path in (DATA, *BINARIES.values())):
        raise SystemExit("missing timing input")
    OUT.mkdir(parents=True, exist_ok=True)
    load_1m, idle = quiet_machine()
    (OUT / "machine-load-before.txt").write_text(
        f"1-minute load: {load_1m:.2f}\n2-second CPU idle: {idle:.1f}%\n")
    print(f"[L131TimingGate] load_1m={load_1m:.2f} cpu_idle_2s={idle:.1f}%", flush=True)
    if load_1m >= 0.9 or idle < 97.0:
        raise SystemExit("timing refused: machine is above the L80 quiet-load gate")
    rows = []
    for strate in range(4):
        for workers in (8, 12):
            for version in BINARIES:
                rows.append(run(strate, workers, version, "warmup", 0))
            for replicate in range(1, 6):
                order = tuple(BINARIES) if replicate % 2 else tuple(reversed(BINARIES))
                for version in order:
                    rows.append(run(strate, workers, version, "measured", replicate))
                    (OUT / "runs-partial.json").write_text(json.dumps(rows, indent=2) + "\n")
    measured = [row for row in rows if row["phase"] == "measured"]
    summary = []
    for strate in range(4):
        for workers in (8, 12):
            old = [row for row in measured if row["strate"] == strate and row["workers"] == workers and row["version"] == "base"]
            new = [row for row in measured if row["strate"] == strate and row["workers"] == workers and row["version"] == "l131"]
            item = {"strate": strate, "workers": workers, "replicates_per_version": 5}
            for key in ("lod02_ready_s", "whole_view_ready_s"):
                old_med, new_med = statistics.median(row[key] for row in old), statistics.median(row[key] for row in new)
                item[f"base_{key}_median"] = old_med
                item[f"l131_{key}_median"] = new_med
                item[f"delta_pct_{key}"] = round(100.0 * (new_med / old_med - 1.0), 2)
                item[f"base_{key}_values"] = [row[key] for row in old]
                item[f"l131_{key}_values"] = [row[key] for row in new]
            summary.append(item)
    (OUT / "summary.json").write_text(json.dumps({"runs": rows, "summary": summary}, indent=2) + "\n")
    return 0
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -0,0 +1,44 @@
 #!/usr/bin/env python3
 """Create the isolated L132 owner snapshot with a native plan for existing FI strate 1."""
 from __future__ import annotations
 import json
 from pathlib import Path
 ROOT = Path(__file__).resolve().parents[4]
 SOURCE = ROOT / "Standalone/data/owner_world.json"
 MANIFEST = ROOT / "Saved/Linux/l132/fixtures/owner-native-fi.world-assembly.json"
 LAYOUT = ROOT / "Saved/Linux/l132/fixtures/owner-native-fi.resolved-layout.json"
 OUTPUT = ROOT / "Saved/Linux/l132/fixtures/owner_world_native_fi.json"
 def main() -> int:
    owner = json.loads(SOURCE.read_text(encoding="utf-8"))
    manifest_text = MANIFEST.read_text(encoding="utf-8").strip()
    layout_text = LAYOUT.read_text(encoding="utf-8").strip()
    manifest = json.loads(manifest_text)
    layout = json.loads(layout_text)
    islands = manifest.get("floating_islands", [])
    native = [row for row in islands if row.get("strate_index") == 1]
    resolved = [row for row in layout.get("strates", [])
                if row.get("strate_index") == 1]
    if len(native) != 1 or len(resolved) != 1:
        raise SystemExit("native FI snapshot must contain exactly one strate-1 island plan/layout")
    if (resolved[0].get("generator_kind") != "FloatingIslands"
            or resolved[0].get("recipe_id") != "FloatingIslands.ClusterField"
            or resolved[0].get("recipe_version") != 8):
        raise SystemExit("resolved strate 1 is not FloatingIslands.ClusterField v8")
    owner["world_assembly"] = manifest
    owner["core_world_assembly_json"] = manifest_text
    owner["resolved_layout_json"] = layout_text
    OUTPUT.parent.mkdir(parents=True, exist_ok=True)
    OUTPUT.write_text(json.dumps(owner, separators=(",", ":")) + "\n", encoding="utf-8")
    print(f"[L132NativeFISnapshot] path={OUTPUT.relative_to(ROOT)} "
          f"islands={len(native[0].get('manifest', {}).get('plan', {}).get('islands', []))} "
          "strate=1 recipe=FloatingIslands.ClusterField/v8 status=PASS")
    return 0
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -0,0 +1,41 @@
 # L132 — owner density dispatch
 ## Result
 With Core enabled in the owner headless pipeline, the four strates bind to four paths. Unreal’s `bUseVoxelForgeCore` remains opt-in and defaults off. The fast-tier diagnostic reports the Core bindings at the four L80 owner poses and attributes hashed tiles by tile-center height within the resolved stratum bounds.
 | Strate | Owner recipe | Bound path | Tile centers / share |
 |---|---|---|---:|
 | SW (0) | `SurfaceWorld.Heightfield2D` v2 | `SurfaceWorld-native` | 2,640 / 100% |
 | FI (1) | `FloatingIslands.ClusterField` v0 | `compiled-analytic/FloatingIslands` | 2,128 / 100% |
 | TN (2) | `legacy.TunnelNetwork` v0 | `compiled-analytic/TunnelNetwork` | 2,208 / 100% |
 | VS (3) | `legacy.VerticalShafts` v0 | `compiled-analytic/VerticalShafts` | 1,392 / 100% |
 SW has a matching strate/bounds `SurfaceWorld` plan, and its `Heightfield2D` evaluator is valid. FI has a legacy v0 layout record but no matching `FloatingIslandPlan`, so `FloatingIslandFieldV1` cannot bind. The Core owner manifest has zero island plans. TN and VS have legacy recipe IDs, not `Core.Caves.PrimitiveField` v1 or `Core.Lattice.PrimitiveField` v1. Their resolved layouts therefore lack the matching graph recipe and native-field capability. All three fall through to `FLegacyGeneratorFieldAdapter`.
 The dispatch check is in the fast tier and can also be requested from the headless binary with `--density-dispatch-report`. It prints the per-strate bound adapter/path and hashed tile-center path shares. Its tile counts aggregate the four standard owner poses; tiles whose centers fall outside an interior interval are excluded, and a tile spanning a boundary is assigned by its center. Per-view logs are `Saved/Linux/l132/owner-density-dispatch-s*-clang.log`; the printed shares are in `Saved/Linux/l132/logs/verify-fast.log` and `Saved/Linux/l132/fast-summary.json`.
 Across the 8,368 classified tile centers, path shares are 31.5% SurfaceWorld-native, 25.4% compiled-analytic/FloatingIslands, 26.4% compiled-analytic/TunnelNetwork, and 16.6% compiled-analytic/VerticalShafts.
 ## Native FI decision
 The native evaluator is present. `BuildFloatingIslandStratumPlan` can convert the owner’s legacy island parameters to a v8 plan, but the owner’s imported manifest does not contain that plan. The existing automatic-plan branch is guarded by `bImportedOverride` inside the generated-assembly branch, so it does not fill this owner’s missing imported plan.
 I built a candidate v8 plan for the existing owner FI strate without changing the default owner data. Its raw island-route audit passed: 29 route points, 78,336 capsule samples, zero blocked samples, zero unsupported probes, and zero grade failures. The composed owner audit did not pass:
 - Existing compiled-analytic owner: all 3 passage interfaces pass; shell floor violations 0; ripple checks 3/3.
 - Native FI candidate: only 2/3 interfaces pass; the added FI route is not walkable (1/2 strate routes walkable); shell floor violations 13; ripple checks 2/3.
 - Passage tile seams passed for both bindings: 4 pairs, 4,900 shared samples, zero mismatches.
 Native FI is a quality regression on the owner’s current passages, despite its standalone route plan passing. I did not switch the owner. The conditional captures, W8/W12 timing matrix, and Clang/GCC W1/W8/W12 matrix were not run because the candidate failed the composed walk/shell gate. No Core version or output baseline changed; the default owner output remains on its existing bindings. No Linux UE host build was run because there was no qualifying native change or timing matrix.
 ## TN/VS graph translation size
 The active TN `GenerationParams` block has 47 fields; VS `VerticalShaftParams` has 11. Each also has 15 passage settings. Both have `CoreGeometry.GeneratorRecipe=0` and empty `Rooms`, `Tunnels`, and `Stamps` arrays. Native cave/lattice authoring requires at least one explicit room and one edge, with geometry, links, and route data. There is no adapter translating those legacy generator blocks into graph records. This is a substantial procedural migration, not a small recipe mapping, so I did not build it this round.
 ## Verification
 - Fast tier: PASS, 304.0 s, 84 runs and 273 checks; includes four-pose dispatch output.
 - Passage tile seams: compiled-analytic and native FI candidate both PASS at the FI owner pose.
 - Owner walk/shell comparison: default PASS; native candidate FAIL as detailed above.
 - Build stamp: `766b94ca7638475975b0345e5907eebb96158360c384f5d916c78eccbb1aa815`.
@@ -0,0 +1,35 @@
 # VoxelForge — research R46 (read-only): generator capability matrix
 You are a researcher. **Read only: do not edit, create or delete any file, and do not build, run or test anything.**
 Read the code, reports and design docs. Be thorough: verify each claim by hand in the code, and mark each one
 [CODE] file:line, [MEASURED] report, or [INFERENCE]. Branch `assembler/world` (`cbbfd46`).
 ## Why
 The owner approved the next focus (from `Standalone/Research/WorldAssemblerM3/Astra4/REVIEW.md` #3): turn generator
 breadth into playable variety. First we need an honest picture of what each strate/generator family can do today.
 ## Task
 Find every generator family / strate type: surface world, floating islands, caves/cavern, tunnel network, vertical
 shafts, dreamcore/liminal, and any others in the code (Core native, legacy fallback, op stack, composer). For each,
 fill one row:
 - **Core path:** native Core evaluator, legacy fallback, or not in Core at all? Where is it dispatched?
 - **Entrances/exits:** arrival and departure mouths, and the primordial law (arrival → departure walkable).
 - **Interior connectivity:** walkable, and audited by what?
 - **Edits:** does digging (diff layer) work on it in the Core path?
 - **Materials/content:** material IDs, decorations, foliage, lights, anything placeable.
 - **Far terrain:** does it have far LOD/shells?
 - **Performance:** latest measured near-ready, with the report.
 - **Identity:** what makes it look and feel distinct today; is it recognisable without a label?
 - **Owner world:** used in `Standalone/data/owner_world.json`? Which strate letter (SW/FI/TN/VS)?
 - **Gaps:** what's missing for it to be a "place" with its own identity and a destination.
 Then:
 1. Which three families are closest to being distinct places (the owner's example: a grounded cave, an island
   environment, one liminal identity)? What is the smallest work to get each there?
 2. What does the composer (`VoxelSeasonManifest.cpp`, `COMPOSER-NOTES.md`) already do for tagged content, and what's
   the smallest next step?
 3. Risks: places where the Core path silently falls back, or where a family exists in docs but not in code.
 Write plain Markdown: the matrix plus ≤ ~800 words of findings.
@@ -0,0 +1,41 @@
 # VoxelForge R46 — generator capability matrix
 Read-only review of `assembler/world` at `cbbfd46`; no files changed, and no builds, runs, or tests were performed.
 ## Shared dispatch and contracts
 [CODE] The eight `ECaveGeneratorType` values are TunnelNetwork, FlatPlain, CrystalChamber, Maze, SurfaceWorld, VerticalShafts, FloatingIslands, and Underwater. `NativeCaves`, `NativeLattice`, and `ProfiledHeightfield` are optional Core recipes layered onto those types, not additional strate types. [VoxelStrateTypes.h:175](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:175>) [VoxelStrateTypes.h:203](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:203>)
 [CODE] Core binds native SurfaceWorld and FloatingIslands evaluators when matching plans exist; it binds native cave/lattice graph fields when their capabilities are present. Otherwise it attaches a legacy generator adapter. The density dispatcher exposes paths such as `SurfaceWorld-native`, `SurfaceWorld-legacy`, `Caves-native`, and `compiled-analytic/<kind>`. [ShapeWorldInternal.h:600](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:600>) [ShapeWorldInternal.h:640](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:640>) [ShapeWorldInternal.h:649](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:649>) [ShapeWorldInternal.h:3101](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:3101>)
 [CODE] The adapter plans inter-strate passages and resolves the layout before Core evaluates it. The composer’s primordial law checks a player-fit, walk-only path between the center-column interior endpoints; it is an arrival-to-departure test, not a requirement that every disconnected room or shaft join the largest component. [VoxelForgeCoreAdapter.cpp:1545](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp:1545>) [VoxelSeasonManifest.cpp:2194](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelSeasonManifest.cpp:2194>) [VoxelStrateMeasure.h:315](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateMeasure.h:315>)
 [CODE] Core edit transactions become density brushes applied after field composition. The same stage covers native and fallback density paths. [VoxelForgeCore.cpp:3307](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/VoxelForgeCore.cpp:3307>) [ShapeWorldInternal.h:3036](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:3036>) [ShapeWorldInternal.h:5201](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:5201>)
 [CODE] Any strate can author decorations, landmarks, ambient actors, and creatures. Placement supports actors or instanced meshes; Core material samples default to host ID 1 and can carry two resource IDs. These are shared content hooks, not a distinct palette per generator family. [VoxelStrateDefinition.h:352](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateDefinition.h:352>) [VoxelStrateTypes.h:2204](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:2204>) [VoxelForgeCore.h:1273](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h:1273>)
 **Performance key:** L125 is the latest absolute owner four-strata LOD0–2 timing table I found; L130’s paired comparison found no measurable change. L125 labels rows S0–S3, so mapping them to SW/FI/TN/VS in the explicit L109 order is an **[INFERENCE]**. Values below are W8/W12 medians in seconds; they measure the owner layout, not isolated native evaluator costs. [L125:24](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md:24>) [L125:28](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md:28>) [L125:35](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md:35>) [L130:9](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md:9>) [L109:21](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux109/REPORT.md:21>)
 ## Matrix
 | Family / owner | Core path | Entrances, connectivity, and primordial law | Edits, materials, and content | Far terrain and performance | Identity and gaps |
 |---|---|---|---|---|---|
 | **SurfaceWorld — SW** | [CODE] Native `Heightfield2D` when a matching surface plan binds; legacy SurfaceWorld fallback otherwise. [ShapeWorldInternal.h:600](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:600>) [ShapeWorldInternal.h:6685](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:6685>) | [CODE] Owner export enables an open surface entry; SW also supplies the 0–1 departure mouth. [MEASURED] The shared route audit passed 21,425/21,425 centerline samples. [owner_world.json:1](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/data/owner_world.json:1>) [L125:39](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux125/REPORT.md:39>) | [CODE] Digging works. Surface supports biome terrain/material signals, water, and the shared placement hooks; no family-specific content pack is proven in the owner export. [VoxelStrateTypes.h:1609](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:1609>) | [CODE] Common mesh LOD and far shells; native surface plans also get far ground/cap refinement. [MEASURED] **SW:** 0.780/0.807 near-ready. [VoxelForgeCore.cpp:2996](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/VoxelForgeCore.cpp:2996>) [VoxelForgeCore.cpp:3073](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/VoxelForgeCore.cpp:3073>) | [INFERENCE] Outdoor hills, mountains, rivers, and beaches have a legible silhouette. It still needs distinctive foliage/materials, sound, and a destination to read as a complete place. |
 | **FloatingIslands — FI** | [CODE] Native island field when a matching island plan binds; otherwise falls through to the legacy analytic path. [ShapeWorldInternal.h:620](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:620>) [ShapeWorldInternal.h:6692](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:6692>) | [CODE] Owner route enters from SW and departs toward TN; native island route audits check capsule clearance and support. [MEASURED] The owner passage checks passed. [MEASURED] L67 reported the owner FI path as `compiled-analytic/FloatingIslands`, not native; the reason was unresolved in R36. [L67:5](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux67/REPORT.md:5>) [Research36:11](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Research36/REPORT.md:11>) | [CODE] Digging works; foliage, landmarks, ambient actors, and lights can use shared placement systems. [INFERENCE] No island-specific owner palette/content is established by the export. | [CODE] Common far mesh and shell paths. [MEASURED] **FI:** 0.981/0.962 near-ready in the owner layout. | [INFERENCE] Floating land silhouettes can be immediately recognizable. Confirm native dispatch, then add an island ecology, a landmark, and a clear route/destination. |
 | **TunnelNetwork — TN** | [CODE] The owner’s regular path is Core’s legacy/compiled-analytic fallback. `NativeCaves` is optional for TN/Underwater and evaluates authored room/tunnel graphs. [VoxelForgeCoreAdapter.cpp:145](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp:145>) [VoxelGenerator.cpp:2645](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2645>) | [CODE] Owner arrival from FI and departure toward VS. [MEASURED] Inter-strate walkability passes; that does not prove every interior room is connected. Native cave fixture flood-fill connected its chosen arrival/departure pair. [L54:21](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux54/REPORT.md:21>) | [CODE] Digging works. Generic cave decorations/landmarks/lighting are available; there is no family-specific Core material palette. | [CODE] Common far LOD/shells. [MEASURED] **TN:** 1.025/0.965 near-ready in the owner layout. Optional native-cave fixture: 0.177 s near ring and 0.706 s cold whole view, a different workload. [L54:37](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux54/REPORT.md:37>) | [INFERENCE] Rooms and tunnels read as caves, but the owner route lacks a content-defined destination. Small cave graph and a landmark/content pack would make it a place; translating the owner’s legacy parameters to native cave records remains separate work. |
 | **FlatPlain** | [CODE] Legacy fallback/op stack only; it uses the slab builder. [VoxelGenerator.cpp:2600](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2600>) [VoxelDensityOpStack.cpp:9373](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelDensityOpStack.cpp:9373>) | [CODE] No intrinsic mouths; shared passage planner supplies endpoints. [INFERENCE] Its open floor/ceiling band may connect the selected endpoints, but no family-specific arrival/departure audit was found. | [CODE] Digging works; shared decorations/landmarks can populate the chamber. | [CODE] Common far LOD/shells. [MEASURED] No separate near-ready timing found. | [INFERENCE] Open underground plain with columns. Needs a distinctive floor/ceiling profile, content, and destination; it has no native Core slab recipe. |
 | **CrystalChamber** | [CODE] Same slab op-stack builder as FlatPlain; distinctness comes from parameter values, especially ceiling roughness. [VoxelGenerator.cpp:2600](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2600>) | [CODE] Same shared-mouth arrangement as FlatPlain; no family-specific walk audit found. | [CODE] Digging works. Crystal decoration is authorable through shared placement, not guaranteed by the geometry type. [VoxelStrateTypes.h:169](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:169>) | [CODE] Common far LOD/shells. [MEASURED] No separate near-ready timing found. | [INFERENCE] Hanging formations could distinguish it, but parameters alone do not supply crystal materials, lighting, or a destination. |
 | **Maze** | [CODE] Legacy maze op stack; optional `NativeLattice` graph recipe, which is shared with VerticalShafts rather than a dedicated native maze generator. [VoxelForgeCoreAdapter.cpp:159](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp:159>) [VoxelGenerator.cpp:2592](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2592>) | [CODE] Mouths are shared-planner endpoints; native lattice fixtures test capsule reachability between chosen endpoints. [MEASURED] L60 native lattice fixture: 0.561 s near ring, 1.701 s whole view—not the owner near-ready workload. [L60:19](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux60/REPORT.md:19>) [L60:36](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux60/REPORT.md:36>) | [CODE] Digging works; common content hooks apply. | [CODE] Common far LOD/shells; L60 streamed the lattice fixture through LOD0–8. [L60:15](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux60/REPORT.md:15>) | [INFERENCE] Tight branching corridors are a recognizable grammar, but the native fixture’s helix/maze graph needs a content destination and stronger per-seed identity. |
 | **VerticalShafts — VS** | [CODE] Legacy shaft op stack; optional `NativeLattice` is a generic authored graph, not a shaft-specific Core evaluator. [VoxelGenerator.cpp:2622](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2622>) | [CODE] Owner arrival comes from TN; the four-strata export has no lower fifth-stratum passage. [MEASURED] The composer found a VerticalShafts arrival/departure violation; L58’s lattice route passed but was a helix. [COMPOSER-NOTES.md:1437](</home/jahni/VoxelM/Plugins/VoxelForge/COMPOSER-NOTES.md:1437>) [Linux58:11](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux58/REPORT.md:11>) | [CODE] Digging works; generic props and lights can be placed. | [CODE] Common far LOD/shells. [MEASURED] **VS:** 0.879/0.838 near-ready in owner layout. | [INFERENCE] Vertical silhouettes could distinguish it, but the native graph example is not an open shaft. Needs a shaft-specific core, safe landings, and a proven route. |
 | **Underwater** | [CODE] TunnelNetwork density plus water behavior; optional NativeCaves recipe is accepted. No separate native water generator recipe. [VoxelGenerator.cpp:2638](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelGenerator.cpp:2638>) [Unreal1:131](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Unreal1/REPORT.md:131>) | [CODE] Shared passage mouths; composer’s law is walk-only, so it does not certify swimming or water traversal. [INFERENCE] A flooded route needs dry walkable sections or a separate traversal rule. | [CODE] Digging works; water and shared content are available, but the native assembly recipe does not itself provide an authored water feature. | [CODE] Common far terrain; far water presentation is not established here. [MEASURED] No separate near-ready timing found. | [INFERENCE] “Flooded cave” is a plausible identity, but water, lighting, air pockets, and destination spaces need authored treatment. |
 | **Dreamcore / liminal** | [CODE] No `Dreamcore` generator type. Existing Core stamps/motif fields are overlays; motif override currently requires a resolved SurfaceWorld strate. [VoxelStrateTypes.h:175](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:175>) [WorldAssemblyPrototype.h:568](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Source/WorldAssemblyPrototype.h:568>) | [CODE] Inherits mouths and connectivity from its base family; motif fixtures preserve route keepouts. [MEASURED] L60 motif overlay: 0.493 s near ring, 1.326 s whole view. [Linux56:21](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux56/REPORT.md:21>) [L60:35](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux60/REPORT.md:35>) | [CODE] Digging applies to the composed field; current motif kinds include carve arch/ellipsoid and fill pillar/dais/monolith/platform. [VoxelStrateTypes.h:222](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateTypes.h:222>) | [CODE] Base field uses common far LOD/shells. Motifs have LOD coverage, but no liminal-specific far treatment. | [INFERENCE] Motifs alone do not read as dreamcore. It needs a repeated spatial grammar, coherent palette/light/sound, and an explorable destination. Not in owner world. |
 Owner mapping: [MEASURED] the owner export references four fixed strata and opens the surface; the named four-family owner route is SW/FI/TN/VS. [CODE] The L125–L130 timings are for that owner layout. [owner_world.json:1](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/data/owner_world.json:1>) [L109:21](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux109/REPORT.md:21>) [L120:23](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux120/REPORT.md:23>)
 ## Findings
 1. **Closest to distinct places: TN caves, FI, and liminal overlays.** [INFERENCE] TN already has cave geometry and route proof: add one authored destination chamber plus a small landmark/material/light kit. FI already has a distinctive suspended-land silhouette and route support: first confirm its native dispatch, then add foliage, a landmark, and route cues. Liminal is the smallest overlay slice: reuse the flat/profiled base and existing monolith/platform stamps, then define one repeatable anomaly pattern and a matching content kit. These need authored destinations and themes more than new density families.
 2. **Composer status and smallest next step.** [CODE] `VoxelSeasonManifest.cpp` rolls candidates from a corpus, measures them, rejects vacuous/fragmented/primordial-law failures, and selects for grounded/outlier mix plus archetype/recipe variety. Promoted records carry an archetype tag and corpus provenance is tagged `project`, `default`, or `promoted`. [VoxelSeasonManifest.cpp:2523](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Private/VoxelSeasonManifest.cpp:2523>) [COMPOSER-NOTES.md:431](</home/jahni/VoxelM/Plugins/VoxelForge/COMPOSER-NOTES.md:431>) [COMPOSER-NOTES.md:1466](</home/jahni/VoxelM/Plugins/VoxelForge/COMPOSER-NOTES.md:1466>) Strate and biome gameplay tags are stored, but theme draws for materials, creatures, decorations, and audio are still open. [VoxelStrateDefinition.h:389](</home/jahni/VoxelM/Plugins/VoxelForge/Source/VoxelForge/Public/VoxelStrateDefinition.h:389>) [COMPOSER-NOTES.md:1484](</home/jahni/VoxelM/Plugins/VoxelForge/COMPOSER-NOTES.md:1484>) [INFERENCE] Smallest step: tag one real content class with multiple theme tags and let one seed-selected family draw a coherent, reviewable mini-pack.
 3. **Risks.** [CODE] Missing native plans/capabilities reach the legacy binding; path diagnostics are needed to distinguish them. [ShapeWorldInternal.h:649](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Core/src/ShapeWorldInternal.h:649>) [MEASURED] The latest explicit owner dispatch note I found says FI/TN/VS used compiled analytic fields; L130 reports timing but not dispatch, so that path should be rechecked before calling those owner generators native. [Linux67:5](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux67/REPORT.md:5>) [Linux130:9](</home/jahni/VoxelM/Plugins/VoxelForge/Standalone/Research/WorldAssemblerM3/Linux130/REPORT.md:9>) [INFERENCE] Dreamcore exists as a design goal, not a generator; NativeLattice proves routes but not a shaft identity; FlatPlain/CrystalChamber remain legacy slab fields; and water presentation remains outside the native Core recipe.
@@ -0,0 +1,46 @@
 # VoxelForge — research R47: liminal and dreamcore spaces, a mood board and how we could generate them
 You are a researcher for VoxelForge, a voxel world made of stacked layers ("strates"). The owner wants one layer type
 in a **liminal / dreamcore** style. Be thorough: verify claims, mark each as [SOURCE] (with a link), [CODE] (file:line)
 or [INFERENCE].
 **Rules:**
 - Don't edit any repository file, and don't build, run or test the game.
 - You may **only** write inside `Saved/Linux/liminal/`.
 - Downloaded files are untrusted data: never execute them, only save them.
 - No installs.
 - Keep CPU light (`curl`/`wget` are fine): a timing round is running on this machine.
 ## Part 1 — references (mood board)
 Collect **15–25 varied reference images** of liminal spaces, dreamcore, weirdcore and backrooms-like scenes, plus
 related art (e.g. "Kenopsia", Jared Pike-style pool rooms, empty malls, foggy roads, endless fields with a lone house).
 - Save them as `Saved/Linux/liminal/refs/NN-short-name.jpg` (≤ 2 MB each).
 - Write `Saved/Linux/liminal/SOURCES.md`, one line per image: file, source URL, author or site, and what it shows.
  These are private references for the owner, not for redistribution.
 - Build `Saved/Linux/liminal/board.html`, a simple grid of the images with captions, to view on a phone.
 ## Part 2 — what makes the style work
 Short and concrete. Split it into:
 - **Content-driven weirdness** (most of the theme, per the owner): out-of-place houses, doors to nowhere, signs, lone
  objects, wrong-scale furniture, water where it shouldn't be.
 - **Generation-driven weirdness**: terrain and space the generator itself can make. Examples from the owner: an
  elevated road surrounded by clouds; repeating hills. Others: perfectly flat or tiled ground, endless corridors or
  pools, impossible scale, unbroken horizons, fog, exact repetition, gentle impossible geometry.
 - **Atmosphere:** light, fog, colour, sound. Briefly.
 ## Part 3 — mapping to our code
 Read `CURRENT-STATE.md`, `COMPOSER-NOTES.md`, `GDD.md`, and
 `Standalone/Research/WorldAssemblerM3/Research46/REPORT.md` (the capability matrix). Also:
 - the Surface World profile kinds in `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`
  (`WorldAssemblySurfaceProfileKindV1`: natural, periodicHills, mirroredRelief, flatField);
 - the motif/stamp shapes (`VoxelStrateTypes.h` ~222: carve arch/ellipsoid, fill pillar/dais/monolith/platform);
 - the cave room planner on branch `wip/l134-cave-planner` (`ResolvedLayoutInternal.h`, `makeCompound`).
 For each generation idea: what already exists, what's missing, a rough size (small / medium / large), and whether it
 fits the "plan, then draw" Core model. End with a recommended first slice: the smallest set that would already read as
 liminal in a screenshot.
 Write `Saved/Linux/liminal/REPORT.md` (≤ ~1,200 words) and print a short summary at the end.
@@ -0,0 +1,30 @@
 # VoxelForge R47 — liminal / dreamcore
 ## Result
 [INFERENCE] Start with a rare, content-led anomaly on a flat SurfaceWorld: one ordinary, recognizable object placed where it makes no sense, framed by a quiet empty field and mild horizon fog. This can read in a screenshot without a new generator family.
 [CODE] The requested references describe different snapshots: `CURRENT-STATE.md` labels the tree L132/Core v227 (`CURRENT-STATE.md:3,7`), while the live Core header says evaluator v236 (`Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h:513`). R46 calls itself a review of an earlier `assembler/world` snapshot (`Standalone/Research/WorldAssemblerM3/Research46/REPORT.md:3`). The mapping below follows the live source; R46 is historical context.
 ## 1. What makes it work
 - **Content-driven weirdness (the main signal).** [INFERENCE] Keep most geometry ordinary, then break one semantic expectation: a lone house in an indoor hall; a door standing in a field; a sign that points nowhere; a child-sized chair in a huge room; or still pool water in a dry corridor. Repeat one object exactly or vary its scale to make the wrongness legible. [SOURCE] ETH Zürich describes dreamcore as familiar scenes that are hard to place, including impossible proportions; Jared Pike’s *Dream Pools* frames endless pool environments as eerie nostalgia. [ETH Zürich](https://dbt.arch.ethz.ch/latent-spaces/) · [Jared Pike](https://www.jaredpike.art/projects/dream-pools/)
 - **Generation-driven weirdness.** [INFERENCE] Use perfectly flat ground, exact repeated hills, a corridor or pool that returns to itself, an elevated road over clouds, oversized rooms, or a horizon with no visible edge. Favor one simple rule repeated cleanly over unrelated noise. [SOURCE] Liminal spaces often use familiar passage places with their expected people or activity absent, making them uncanny. [Liminal space](https://en.wikipedia.org/wiki/Liminal_space) [SOURCE] ETH Zürich describes dreamcore as recognizable but ambiguous scenes. [ETH Zürich](https://dbt.arch.ethz.ch/latent-spaces/)
 - **Atmosphere.** [INFERENCE] Try cool fluorescent light, a weak warm pool of color, low horizon fog and sparse room tone (fluorescent hum, wind, or a looping distant splash); leave large areas quiet. [SOURCE] ETH Zürich notes that looping sound and ambiguous cues help make dreamcore recognizable but not fully explainable. [ETH Zürich](https://dbt.arch.ethz.ch/latent-spaces/)
 ## 2. Mapping to VoxelForge
 | Idea | Already exists / missing | Size and “plan, then draw” fit |
 |---|---|---|
 | Wrong-place props and landmarks | [CODE] Shared decorations and rare landmarks can spawn actors or instanced meshes with deterministic placements (`ARCHITECTURE.md:267-349`; `Source/VoxelForge/Public/VoxelStrateTypes.h:2407,2471`). [CODE] Generated schema-2 slots currently carry no content/visual record, and theme draws for materials, creatures and audio remain open (`COMPOSER-NOTES.md:115-117,1484-1485`). | [INFERENCE] **Small** for one authored prop kit; **medium** to make the composer select/store coherent content. [INFERENCE] Fits a resolved placement plan and later Unreal draw; these props are not Core density geometry. |
 | Flat ground and repeating hills | [CODE] Surface profile kinds include `flatField`, `periodicHills` and `mirroredRelief`; seeded phases are resolved during planning (`VoxelForgeCore.h:560-610`). No profile kind describes tiled ground materials. | [INFERENCE] **Small** to select a flat or periodic profile; **medium** for a dedicated tiled material/pattern pass. [CODE] Yes: profile parameters are recipe/plan data consumed by the Core field. |
 | Raised road among clouds | [CODE] Floating Islands is an existing family (`VoxelStrateTypes.h:196-197`); persistent ceiling/floor actors can make a cloud sea (`ARCHITECTURE.md:457-464`), and landmarks can carry a mesh bridge. [INFERENCE] There is no demonstrated Core road/path structure that couples its geometry to the island route. | [INFERENCE] **Medium** for a finite authored bridge or platform chain; **large** for a robust generated road network. [INFERENCE] A finite road can be planned as records and drawn as mesh/content; cloud actors stay in Unreal presentation, outside Core density evaluation. |
 | Endless corridors and pools | [CODE] The cave planner makes a deterministic finite room-and-tunnel graph between passage mouths (`VoxelForgeCore.h:1314-1324`); `makeCompound` emits two to four overlapping room primitives (`ResolvedLayoutInternal.h:3037-3045`). Core exposes water channels (`VoxelForgeCore.h:515-519`). [INFERENCE] The planner is not an endless loop grammar and does not specify a tiled pool basin/waterline. | [INFERENCE] **Medium** for a finite repeated room/pool set-piece; **large** for continuous repeat with reliable traversal and water presentation. [CODE] Finite rooms/edges fit plan-then-draw; truly unbounded repetition needs a new deterministic local-repeat field/streaming rule. |
 | Impossible scale, horizon and geometry | [CODE] Resolved stamps already include carve ellipsoid/arch and fill pillar/dais/monolith/platform with bounded, stable placement (`VoxelForgeCore.h:912-941`); stamps are composed after boundaries/passages (`ARCHITECTURE.md:2242-2265`). [INFERENCE] They can sell oversized objects or a standalone arch, but not non-Euclidean topology or a genuinely impossible connection. | [INFERENCE] **Small** for bounded silhouette changes; **large** for topology-changing spaces. [CODE] Bounded stamp records fit plan-then-draw; topology changes do not fit the current finite stamp vocabulary. |
 | Fog, color and sound | [CODE] Per-strate fog, skylight tint/intensity and persistent layer actors exist (`ARCHITECTURE.md:457-470`; `VoxelStrateDefinition.h:283-362`). [CODE] Composer theme draws for audio are still open (`COMPOSER-NOTES.md:1484-1485`). | [INFERENCE] **Small** to reuse fog/light settings; **medium** to author a coherent audio/theme selection. [INFERENCE] Fits a presentation record selected before draw, but remains outside Core density planning. |
 [CODE] The game design requires every strate to keep a findable open-air entrance and exit and says anomalies should be rare and stand apart from grounded neighbours (`GDD.md:132-153`). [CODE] The `motif_family_override` prototype path is restricted to resolved SurfaceWorld/flatField recipes (`Standalone/Source/WorldAssemblyPrototype.h:921-943`); the shared stamp vocabulary itself is broader.
 ## Recommended first slice
 [INFERENCE] Author one rare SurfaceWorld `flatField` layer with a single familiar doorway or small house mesh placed alone at an implausible scale, plus low horizon fog and one soft light tint. Keep the rest empty; the viewer should recognize the object before noticing the place has no sensible context. This uses existing profile, placement and atmosphere hooks, so the screenshot slice is **small** and does not require a new density family. [CODE] The mesh placement/presentation remains separate from Core’s density plan, and generated schema-2 slots do not yet carry its visual record (`COMPOSER-NOTES.md:115-117`); a composer-ready version will need that record and theme tags.
@@ -0,0 +1,28 @@
 # Reference image sources
 Private visual references for the VoxelForge owner. This is not a redistribution set; consult each source page and its rights statement before reusing an image. These are local display copies; some were resized to meet the per-image size limit.
 - `01-backrooms-origin.jpg` — [SOURCE] [Bill Magritz (creator) / Bob Mazza (copyright holder)](https://commons.wikimedia.org/wiki/File:HobbyTown_USA_Oshkosh_interior_under_construction_2002_(The_Backrooms).jpg); HobbyTown USA Oshkosh interior under construction 2002, the image associated with “The Backrooms”.
 - `02-empty-office.jpg` — [SOURCE] [Ged Carroll](https://commons.wikimedia.org/wiki/File:Empty_office.jpg); Empty office interior.
 - `03-empty-mall-hallway.jpg` — [SOURCE] [Michael Rivera (Mjrmtg)](https://commons.wikimedia.org/wiki/File:Empty_Hallway,_Tallahassee_Mall.JPG); Tallahassee Mall hallway.
 - `04-mall-source.jpg` — [SOURCE] [Jtalledo](https://commons.wikimedia.org/wiki/File:Mall_at_The_Source_empty.jpg); Mall at The Source, with people present.
 - `05-ruoholahti-evening.jpg` — [SOURCE] [JIP](https://commons.wikimedia.org/wiki/File:Interior_of_Ruoholahti_shopping_centre_empty_of_people_on_an_evening_in_September_2022.jpg); Ruoholahti shopping centre interior, September 2022.
 - `06-city-center-night.jpg` — [SOURCE] [JIP](https://commons.wikimedia.org/wiki/File:Interior_of_City-Center_empty_of_people_on_a_night_in_January_2025.jpg); City-Center shopping-centre interior at night, January 2025.
 - `07-school-hallway.jpg` — [SOURCE] [Warren LeMay](https://commons.wikimedia.org/wiki/File:Hallway,_Log_Cabin_Association_Elementary_School,_Barkers_Creek,_NC_(39684209853).jpg); Hallway in Log Cabin Association Elementary School, Barkers Creek, North Carolina.
 - `08-central-high-hallway.jpg` — [SOURCE] [Thomas J. O’Halloran](https://commons.wikimedia.org/wiki/File:Mostly_empty_hallway_at_Central_High_School_in_Little_Rock.tif); Mostly empty hallway at Central High School, Little Rock.
 - `09-hearst-pool.jpg` — [SOURCE] [Mike McBey](https://commons.wikimedia.org/wiki/File:Indoor_pool,_Hearst_Castle_(32062000267).jpg); Indoor pool at Hearst Castle.
 - `10-ymca-pool.jpg` — [SOURCE] [Joe Mabel](https://commons.wikimedia.org/wiki/File:Vancouver_-_Robert_Lee_YMCA_pool_01.jpg); Robert Lee YMCA pool, Vancouver.
 - `11-jerma-hotel-pool.jpg` — [SOURCE] [Anonymous uploader](https://commons.wikimedia.org/wiki/File:Jerma_Hotel_Indoor_Pool_(first_angle).jpg); Jerma Hotel indoor pool.
 - `12-dream-pools-01.jpg` — [SOURCE] [Jared Pike (artist’s official site)](https://www.jaredpike.art/projects/dream-pools/); Dream Pools series.
 - `13-dream-pools-02.jpg` — [SOURCE] [Jared Pike (artist’s official site)](https://www.jaredpike.art/projects/dream-pools/); Dream Pools series.
 - `14-foggy-road.jpg` — [SOURCE] [Dennis Bruijn](https://commons.wikimedia.org/wiki/File:Foggy_Road_(67154193).jpeg); Foggy Road (500px image).
 - `15-driving-through-mist.jpg` — [SOURCE] [Tomasz Zagórski (Unsplash contributor)](https://commons.wikimedia.org/wiki/File:Driving_through_mist_(Unsplash).jpg); Driving through mist.
 - `16-foggy-campus.jpg` — [SOURCE] [Ramesh Lalwani](https://commons.wikimedia.org/wiki/File:Foggy_Morning_in_IIT.jpg); Foggy Morning in IIT.
 - `17-empty-playground.jpg` — [SOURCE] [Ian Paterson](https://commons.wikimedia.org/wiki/File:Empty_playground_-_geograph.org.uk_-_4118218.jpg); Empty playground, Geograph image 4118218.
 - `18-playground-park.jpg` — [SOURCE] [mycurrency.com (uploader credit)](https://commons.wikimedia.org/wiki/File:Empty_Playground_in_a_park.jpg); Empty playground in a park.
 - `19-lone-house.jpg` — [SOURCE] [Mayqel](https://commons.wikimedia.org/wiki/File:Lone_House.jpg); Lone House, Blender render.
 - `20-door-to-nowhere.jpg` — [SOURCE] [Benmckune](https://commons.wikimedia.org/wiki/File:Door_to_Nowhere_Winchester_House_6-5-06.jpg); “Door to Nowhere” at Winchester Mystery House.
 - `21-abandoned-theater.jpg` — [SOURCE] [Noki Va](https://commons.wikimedia.org/wiki/File:Abandoned_Theater_(97702985).jpeg); Abandoned Theater.
 - `22-empty-retail-space.jpg` — [SOURCE] [Wikimedia Commons (uploader credit on source page)](https://commons.wikimedia.org/wiki/File:Empty_Retail_Space.jpg); Empty retail space.
 - `23-historic-rail-platform.jpg` — [SOURCE] [Ben Brooksbank](https://commons.wikimedia.org/wiki/File:Euston_railway_station_geograph-2197358-by-Ben-Brooksbank.jpg); Euston railway station, historic view.
 - `24-empty-airport-terminal.jpg` — [SOURCE] [Matt @ PEK](https://commons.wikimedia.org/wiki/File:Empty_terminal_in_TPE_airport_(4287773502).jpg); Empty terminal in TPE airport.
@@ -70,6 +70,8 @@ namespace
        bool HasRenderDistanceOverride=false;
        int RenderDistanceOverride=0;
        bool FloatingIslandsRecipe=false;
        bool NativeOwnerFloatingIslandsRecipe=false;
        bool DensityDispatchReport=false;
        bool CavesRecipe=false;
        bool LatticeRecipe=false;
        int LatticeStrateIndex=-1;
@@ -1432,6 +1434,8 @@ namespace
                    "  --core-snapshot=FILE (benchmark the exact resolved Core snapshot from Unreal)\n"
                    "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                    "  --seed=N --recipe=surface-world|floating-islands|caves|lattice\n"
                    "  --native-owner-fi (build the existing owner FI plan; leave other strates intact)\n"
                    "  --density-dispatch-report (print bound path per strate and tile hashes)\n"
                    "  --lattice-strate=N (opt one Maze or VerticalShafts strate into Core.Lattice)\n"
                    "  --landmark-chamber-demo (opt-in SW cavern room and swept tunnel)\n"
                    "  --ore-veins-demo (opt-in material-only SW capsule veins)\n"
@@ -1490,6 +1494,9 @@ namespace
            else if(arg=="--resolved-layout-only")options.ResolvedLayoutOnly=true;
            else if(arg=="--audit-resolved-layout-boundaries")options.AuditResolvedLayoutBoundaries=true;
            else if(arg=="--audit-resolved-layout-passages")options.AuditResolvedLayoutPassages=true;
            else if(arg=="--native-owner-fi")options.NativeOwnerFloatingIslandsRecipe=true;
            else if(arg=="--density-dispatch-report")
            {options.DensityDispatchReport=true;options.StreamHash=true;options.StreamHashTiles=true;}
            else if(arg=="--audit-landmark-reachability")options.AuditLandmarkReachability=true;
            else if(arg=="--audit-native-caves")options.AuditNativeCaves=true;
            else if(arg=="--audit-native-lattice")options.AuditNativeLattice=true;
@@ -1819,7 +1826,9 @@ int main(int argc,char** argv)
    else if(!StandaloneWorldAssemblyPrototype::AttachRound1WorldAssemblyPrototype(
        *ownerWorld,ownerJsonRoot,error,{},&worldAssembly))
    {std::fprintf(stderr,"World assembler prototype setup failed: %s\n",error.c_str());return 2;}
-    if(!useExportedCorePlan&&options.FloatingIslandsRecipe
+    if(((!useExportedCorePlan&&options.FloatingIslandsRecipe)
        ||(options.NativeOwnerFloatingIslandsRecipe
            &&worldAssembly.floatingIslands.empty()))
        &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
            *ownerWorld,ownerJsonRoot,worldAssembly,error))
    {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
@@ -1852,15 +1861,17 @@ int main(int argc,char** argv)
        const std::string variant=options.LatticeRecipe
            ?"lattice/"+std::to_string(options.LatticeStrateIndex)
            :options.CavesRecipe?"caves"
-                :options.FloatingIslandsRecipe?"floating-islands":"surface-world";
+                :(options.FloatingIslandsRecipe||options.NativeOwnerFloatingIslandsRecipe)
                    ?"floating-islands":"surface-world";
        const bool layoutResolved=useExportedCorePlan
            &&!options.NativeOwnerFloatingIslandsRecipe
            ?StandaloneWorldAssemblyPrototype::ImportExportedResolvedLayout(
                ownerJsonRoot,resolvedLayout,error)
            :StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
                *ownerWorld,worldAssembly,variant,resolvedLayout,error);
        if(!layoutResolved)
        {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
-        if(useExportedCorePlan
+        if(useExportedCorePlan&&!options.NativeOwnerFloatingIslandsRecipe
            &&!StandaloneWorldAssemblyPrototype::ValidateExportedCorePlanMatchesOwner(
                *ownerWorld,worldAssembly,resolvedLayout,error))
        {std::fprintf(stderr,"Unreal-resolved Core plan/owner slot validation failed: %s\n",error.c_str());return 2;}
@@ -2113,6 +2124,65 @@ int main(int argc,char** argv)
            controls.controlsRejectedAsExpected,controls.controlsRun,controls.passed?"PASS":"FAIL");
        if(!controls.passed)
        {for(const auto& failure:controls.failures)std::printf("[ResolvedLayoutValidatorControlFailure] %s %s\n",failure.code.c_str(),failure.detail.c_str());return 2;}
        if(options.DensityDispatchReport)
        {
            const auto& slots=ownerWorld->Manager->GetLayout();
            for(const auto& stratum:resolvedLayout.strates)
            {
                const auto slot=std::find_if(slots.begin(),slots.end(),[&](const auto& candidate)
                    {return candidate.StrateIndex==stratum.strateIndex;});
                bool native=false;
                std::string path,adapter;
                if(slot!=slots.end()&&stratum.generatorKind=="SurfaceWorld")
                {
                    const auto plan=std::find_if(worldAssembly.plan.strates.begin(),
                        worldAssembly.plan.strates.end(),[&](const auto& candidate)
                        {return candidate.strateIndex==stratum.strateIndex
                            &&candidate.bottomChunkZ==slot->BottomChunkZ
                            &&candidate.topChunkZ==slot->TopChunkZ;});
                    if(plan!=worldAssembly.plan.strates.end())
                    {
                        const VoxelForgeCore::Heightfield2D field(worldAssembly.recipe,*plan);
                        native=field.isValid();
                    }
                    if(native){path="SurfaceWorld-native";adapter="FSurfaceWorldFieldAdapter";}
                }
                else if(slot!=slots.end()&&stratum.generatorKind=="FloatingIslands")
                {
                    const auto plan=std::find_if(worldAssembly.floatingIslands.begin(),
                        worldAssembly.floatingIslands.end(),[&](const auto& candidate)
                        {return candidate.strateIndex==stratum.strateIndex
                            &&candidate.bottomChunkZ==slot->BottomChunkZ
                            &&candidate.topChunkZ==slot->TopChunkZ;});
                    if(plan!=worldAssembly.floatingIslands.end())
                    {
                        const VoxelForgeCore::FloatingIslandFieldV1 field(
                            plan->manifest.recipe,plan->manifest.plan);
                        native=field.isValid();
                    }
                    if(native){path="FloatingIslands-native";adapter="FFloatingIslandFieldAdapter";}
                }
                else if(VoxelForgeCore::HasNativeGraphField(stratum)
                    &&(VoxelForgeCore::IsNativeCaveFieldStratum(stratum)
                        ?stratum.passageCapabilities.hasNativeCaveField
                        :stratum.passageCapabilities.hasNativeLatticeField))
                {
                    native=true;
                    path=VoxelForgeCore::IsNativeLatticeFieldStratum(stratum)
                        ?"Lattice-native":"Caves-native";
                    adapter="FCavesFieldAdapter";
                }
                if(!native)
                {
                    path=stratum.generatorKind=="SurfaceWorld"
                        ?"SurfaceWorld-legacy":"compiled-analytic/"+stratum.generatorKind;
                    adapter="FLegacyGeneratorFieldAdapter";
                }
                std::printf("[DensityDispatch] strate=%d generator=%s recipe=%s version=%u bound_path=%s adapter=%s\n",
                    stratum.strateIndex,stratum.generatorKind.c_str(),stratum.recipeId.c_str(),
                    stratum.recipeVersion,path.c_str(),adapter.c_str());
            }
        }
        if(!options.ResolvedLayoutOutputPath.empty())
            std::printf("[ResolvedLayoutSnapshotOutput] path=%s\n",options.ResolvedLayoutOutputPath.c_str());
        if(auto* root=std::get_if<VFJson::Value::Object>(&ownerJsonRoot.Data))
@@ -2566,15 +2566,9 @@ namespace StandaloneStreamBenchmark
        ShapeRequest.detail=DetailVariant;ShapeRequest.includeFarWorld=bIncludeFarWorld&&!bDeferFarWorld;
        ShapeRequest.roundTunnels=bRoundTunnels;
        ShapeRequest.enhancedTunnelWalls=bEnhancedTunnelWalls;
-        const char* L86DisablePassages=std::getenv(
+        ShapeRequest.validatePassageRoutes=!bCaptureSkipWalkability;
            "VOXELFORGE_L86_DISABLE_PASSAGE_COMPOSITION");
        const bool bL86DisablePassages=L86DisablePassages
            &&L86DisablePassages[0]=='1'&&L86DisablePassages[1]=='\0';
        ShapeRequest.validatePassageRoutes=!bCaptureSkipWalkability&&!bL86DisablePassages;
        if(bCaptureSkipWalkability)
            std::printf("[CaptureWalkabilityGate] validation=deferred geometry_input=unchanged mode=mesh-export\n");
        if(bL86DisablePassages)
            std::printf("[L86PassageCeiling] validation=skipped geometry=passage_composition_disabled diagnostic_only=true\n");
        FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
            bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape,bProfileColumnOverlap,
            FarHorizonLOD8InteriorStepVoxels,bUseSharedColumnCache,
@@ -153,80 +153,6 @@ namespace StandaloneWorldAssemblyPrototype
            candidateCenterSpacing=32;
        }
        const double coreVoxelMetres=static_cast<double>(coreVoxelSizeMicrons)/1000000.0;
        if(std::getenv("VOXELFORGE_AUDIT_LEGACY_ROUTE_GRADE"))
        {
            constexpr std::int32_t legacyCenterSpacing=64;
            constexpr std::int32_t legacyWaypointSpacing=8;
            std::array<GradeSegmentAudit,32> legacySegments{};
            std::uint64_t legacyGradeFailCandidates=0;
            double legacyMinimumGround=std::numeric_limits<double>::infinity();
            double legacyMaximumGround=-std::numeric_limits<double>::infinity();
            for(std::int32_t centerY=-256;centerY<=256;centerY+=legacyCenterSpacing)
            for(std::int32_t centerX=-256;centerX<=256;centerX+=legacyCenterSpacing)
            for(const Direction& direction:directions)
            {
                bool candidateGradeFail=false;
                std::int64_t previousGround=0,previousX=0,previousY=0;
                for(std::int32_t index=0;index<=32;++index)
                {
                    const std::int64_t along=(index-16)*legacyWaypointSpacing;
                    const std::int64_t x=centerX+std::llround(
                        static_cast<double>(along)*direction.x/65536.0);
                    const std::int64_t y=centerY+std::llround(
                        static_cast<double>(along)*direction.y/65536.0);
                    const auto column=finalField.point(WorldAssemblyFixed(static_cast<double>(x)),
                        WorldAssemblyFixed(static_cast<double>(y)),0);
                    const double groundMetres=static_cast<double>(column.groundHeightSubvoxels)
                        *coreVoxelMetres/WorldAssemblySubvoxelsPerVoxel;
                    legacyMinimumGround=std::min(legacyMinimumGround,groundMetres);
                    legacyMaximumGround=std::max(legacyMaximumGround,groundMetres);
                    if(index>0)
                    {
                        const std::int64_t horizontalQ=static_cast<std::int64_t>(std::llround(
                            std::hypot(static_cast<double>(x-previousX),
                                static_cast<double>(y-previousY))*WorldAssemblySubvoxelsPerVoxel));
                        const std::int64_t riseQ=std::abs(
                            column.groundHeightSubvoxels-previousGround);
                        if(horizontalQ==0||riseQ*65536>horizontalQ*GradeQ16)
                        {
                            candidateGradeFail=true;
                            GradeSegmentAudit& segment=legacySegments[
                                static_cast<std::size_t>(index-1)];
                            ++segment.failures;
                            const double grade=horizontalQ>0
                                ?static_cast<double>(riseQ)/static_cast<double>(horizontalQ)
                                :std::numeric_limits<double>::infinity();
                            if(grade>segment.maximumGrade)
                            {
                                segment.maximumGrade=grade;
                                segment.fromGround=previousGround;
                                segment.toGround=column.groundHeightSubvoxels;
                                segment.fromX=previousX;segment.fromY=previousY;
                                segment.toX=x;segment.toY=y;
                            }
                        }
                    }
                    previousGround=column.groundHeightSubvoxels;previousX=x;previousY=y;
                }
                if(candidateGradeFail)++legacyGradeFailCandidates;
            }
            std::printf("[WorldAssemblerLegacyRouteGradeProfile] candidates=648 grade_fail_candidates=%llu ground_range_m=%.3f..%.3f grade_limit_deg=15.000 chord_m=%.3f waypoint_step_m=%.3f center_step_m=%.3f\n",
                static_cast<unsigned long long>(legacyGradeFailCandidates),
                legacyMinimumGround,legacyMaximumGround,256.0*coreVoxelMetres,
                legacyWaypointSpacing*coreVoxelMetres,legacyCenterSpacing*coreVoxelMetres);
            const double metresPerSubvoxel=coreVoxelMetres/WorldAssemblySubvoxelsPerVoxel;
            for(std::size_t segmentIndex=0;segmentIndex<legacySegments.size();++segmentIndex)
            {
                const GradeSegmentAudit& segment=legacySegments[segmentIndex];
                if(segment.failures==0)continue;
                std::printf("[WorldAssemblerLegacyRouteGradeSegment] index=%zu rejected_candidates=%llu max_grade_deg=%.3f ground_m=%.3f->%.3f xy_m=(%.3f,%.3f)->(%.3f,%.3f)\n",
                    segmentIndex,static_cast<unsigned long long>(segment.failures),
                    std::atan(segment.maximumGrade)*57.29577951308232,
                    segment.fromGround*metresPerSubvoxel,segment.toGround*metresPerSubvoxel,
                    segment.fromX*coreVoxelMetres,segment.fromY*coreVoxelMetres,
                    segment.toX*coreVoxelMetres,segment.toY*coreVoxelMetres);
            }
        }
        std::printf("[WorldAssemblerRouteCandidateEnvelope] max_chord_m=%.3f length_variants=%zu center_step_m=%.3f arrival_radius_m=%.3f departure_radius_m=%.3f\n",
            2.0*candidateHalfLengths.front()*coreVoxelMetres,candidateHalfLengths.size(),
            candidateCenterSpacing*coreVoxelMetres,
@@ -89,6 +89,9 @@ TILE_HASH_RE = re.compile(
    r"^\[PipelineTileHash\] lod=(-?\d+) x=(-?\d+) y=(-?\d+) z=(-?\d+) "
    r"density=(0x[0-9a-f]+) mesh=(0x[0-9a-f]+) "
    r"payload=(0x[0-9a-f]+) topology=(0x[0-9a-f]+)$", re.M)
 DENSITY_DISPATCH_RE = re.compile(
    r"^\[DensityDispatch\] strate=(\d+) generator=([^ ]+) recipe=([^ ]+) "
    r"version=(\d+) bound_path=([^ ]+) adapter=([^ ]+)$", re.M)
 TILE_MATERIAL_HASH_RE = re.compile(
    r"^\[PipelineTileMaterialHash\] lod=(-?\d+) x=(-?\d+) y=(-?\d+) z=(-?\d+) "
    r"material=(0x[0-9a-f]+)$", re.M)
@@ -493,6 +496,117 @@ def run_new_owner_plan_stage(runner: VerificationRunner, binary: Path) -> None:
            + ", ".join(deferred_failures))
 def run_density_dispatch_report(runner: VerificationRunner, binary: Path) -> None:
    """Report selected owner density paths and generated tile shares by path."""
    cameras = {
        0: (8.0, 16.0, -372.2626953125),
        1: (25.8369140625, 3.19921875, -737.0),
        2: (19.166015625, -14.2001953125, -753.3740234375),
        3: (-20.0625, -5.068359375, -900.353515625),
    }
    aggregate: dict[int, dict[str, int]] = {}
    bound_paths: dict[int, tuple[str, str, str, int, str]] = {}
    failures: list[str] = []
    for focus_strate, position in cameras.items():
        name = f"owner-density-dispatch-s{focus_strate}-clang"
        camera = "--camera=" + ",".join(
            f"{value:.12f}" for value in (*position, 0.0, 0.0))
        layout_path = OUT / "layouts" / f"{name}.json"
        try:
            row, output = runner.run_cpp(name, binary, OWNER_NEW, "surface-world",
                ["--density-dispatch-report", "--render-distance-chunks=0", camera],
                expected_style=1, workers=8, max_level=8, clip_radius=3,
                layout_path=layout_path)
        except VerificationFailure as error:
            failures.append(f"{name}: {error}")
            continue
        dispatch_rows = DENSITY_DISPATCH_RE.findall(output)
        dispatch = {int(index): (path, generator, recipe, int(version), adapter)
                    for index, generator, recipe, version, path, adapter in dispatch_rows}
        if len(dispatch_rows) != 4 or set(dispatch) != {0, 1, 2, 3}:
            failures.append(f"{name}: expected four unique dispatch rows, got {dispatch_rows}")
            continue
        if not layout_path.is_file():
            failures.append(f"{name}: resolved layout missing at {layout_path}")
            continue
        try:
            layout = json.loads(layout_path.read_text(encoding="utf-8"))
            strata = {int(value["strate_index"]): value for value in layout.get("strates", [])}
            if set(strata) != {0, 1, 2, 3}:
                raise ValueError(f"expected four strata, got {sorted(strata)}")
            voxel_size_um = int(strata[0]["voxel_size_um"])
            if voxel_size_um <= 0:
                raise ValueError(f"invalid voxel_size_um={voxel_size_um}")
        except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError) as error:
            failures.append(f"{name}: cannot classify tiles from resolved layout: {error}")
            continue
        tile_rows = TILE_HASH_RE.findall(output)
        camera_counts = {index: 0 for index in strata}
        for lod_text, _x, _y, z_text, *_hashes in tile_rows:
            lod, z = int(lod_text), int(z_text)
            if lod < 0 or lod > 30:
                failures.append(f"{name}: invalid tile lod={lod}")
                continue
            extent_voxels = 32 << lod
            center_um = (z * extent_voxels + extent_voxels // 2) * voxel_size_um
            matches = [index for index, stratum in strata.items()
                       if int(stratum["interior_bottom_um"]) <= center_um
                       < int(stratum["interior_top_um"])]
            if len(matches) == 1:
                index = matches[0]
                camera_counts[index] += 1
                aggregate.setdefault(index, {}).setdefault(dispatch[index][0], 0)
                aggregate[index][dispatch[index][0]] += 1
        if not tile_rows:
            failures.append(f"{name}: --density-dispatch-report emitted no tile hashes")
        observed = sum(camera_counts.values())
        print(f"[DensityDispatchView] focus_strate={focus_strate} tiles={len(tile_rows)} "
              f"classified_by_center={observed} status={'PASS' if observed else 'FAIL'}",
              flush=True)
        runner.require(f"{name}:dispatch-and-tile-counts",
            observed > 0 and row["status"] == "PASS",
            f"dispatch={dispatch} center_attributed_tiles={camera_counts} "
            f"hashed_tiles={len(tile_rows)}")
        for index, value in dispatch.items():
            previous = bound_paths.get(index)
            if previous is not None and previous != value:
                failures.append(f"strate {index}: bound path changed between views: "
                                f"{previous} vs {value}")
            bound_paths[index] = value
    global_path_counts: dict[str, int] = {}
    for index in range(4):
        path, generator, recipe, version, adapter = bound_paths.get(
            index, ("MISSING", "?", "?", 0, "?"))
        path_counts = aggregate.get(index, {})
        total = sum(path_counts.values())
        for path_name, count in path_counts.items():
            global_path_counts[path_name] = global_path_counts.get(path_name, 0) + count
        details = ",".join(
            f"{key}:{value}/{total} ({100.0 * value / max(1, total):.1f}%)"
            for key, value in sorted(path_counts.items())) or "no tile centers observed"
        print(f"[DensityDispatchStrate] strate={index} generator={generator} recipe={recipe} "
              f"version={version} bound_path={path} adapter={adapter} "
              f"tile_centers={total} path_shares={details}", flush=True)
        if path == "MISSING" or total == 0:
            failures.append(f"strate {index}: dispatch path or tile-center share missing")
        else:
            runner.require(f"owner-density-dispatch-strate-{index}", True,
                f"bound_path={path} tile_center_path_shares={details}")
    all_tiles = sum(global_path_counts.values())
    for path_name, count in sorted(global_path_counts.items()):
        share = 100.0 * count / max(1, all_tiles)
        print(f"[DensityDispatchPathShare] path={path_name} tiles={count}/{all_tiles} "
              f"share={share:.1f}%", flush=True)
    if not all_tiles:
        failures.append("no tile centers were attributed to any bound path")
    runner.require("owner-density-dispatch-report", not failures,
        "; ".join(failures) if failures else
        "four owner poses reported per-strate bound paths and tile-center path shares")
 def run_landmark_reachability(runner: VerificationRunner,
                              binaries: tuple[Path, ...]) -> None:
    for binary in binaries:
@@ -3144,6 +3258,7 @@ def main() -> int:
            except VerificationFailure as error:
                new_plan_failure = str(error)
                print(f"[{runner.tier}] new-owner-plan-stage FAIL {error}", flush=True)
            run_density_dispatch_report(runner, CLANG)
            run_landmark_reachability(runner, (CLANG,))
            run_regression_controls(runner)
            run_hash_pairs(runner, owners)
@@ -31,6 +31,11 @@
 			"Type": "Runtime",
 			"LoadingPhase": "Default"
 		},
 		{
 			"Name": "VoxelForgeLivingPlane",
 			"Type": "Runtime",
 			"LoadingPhase": "Default"
 		},
 		{
 			"Name": "VoxelForgeEditor",
 			"Type": "Editor",
Author	SHA1	Message	Date
Fr0zkaandClaude Opus 5.5	3b71d35eba	experiment: LivingPlane repeatable + standalone UE runtime module (L164) Readback barrier fix (GL_TEXTURE_UPDATE_BARRIER_BIT before glGetTexImage); check_repeatability.py compares full-field checksums across query/capture settings - Intel GPU PASS (3b9d45905c7aafff), llvmpipe PASS, mismatch control fails. New runtime module VoxelForgeLivingPlane (separate from generation): RDG global shader (Shaders/LivingPlane.usf), ping-pong RGBA32F render targets, actor with WPO plane and object inputs, no CPU readback. Compiles in Linux UE 5.7. Windows build: Source/VoxelForgeLivingPlane/*, Shaders/LivingPlane.usf, VoxelForge.uplugin. Setup: UE-SETUP.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-11-02 11:10:43 +01:00
Fr0zkaandClaude Opus 5.5	e1d87eed26	experiment: LivingPlane readable + alive mode (L163) RGBA32F displacement/velocity/imprint field; rolling base relief, grazing light, elevation colours, 7.5 cm contours, follow camera; scenes: roll, rest and wobble, lift-off, second sphere; alive mode = travelling swells + viscoelastic imprint. Intel ADL GT2: ~0.17 ms/step at 512^2. Open: run-to-run difference with queries on/off. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-11-02 10:55:32 +01:00
Fr0zkaandClaude Opus 5.5	5b15595e4a	experiment: LivingPlane - GPU wave-equation height field reacting to a moving sphere (L162) Standalone EGL/OpenGL 4.3 compute runner (runtime GLSL, no shader compiler needed), ping-pong height/velocity field, damped wave + foundation spring + Gaussian sphere push + optional breathing, vertex-displaced render to PNG. Independent of generation. Intel ADL GT2: ~0.08 ms/step at 512^2, ~0.29 ms/step at 1024^2 (wall-time difference). .gitignore now allows Experiments/. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-11-02 10:35:37 +01:00
Fr0zkaandClaude Opus 5.5	eb47d72258	research: R47 liminal/dreamcore style and mapping to Core (text only; images kept local) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-11-01 04:11:52 +01:00
Fr0zkaandClaude Opus 5.5	95bf654fbc	docs: AGENTS.md for Codex (standing rules + working procedure) Codex only auto-loads AGENTS.md; CodexGuidance.md was never read. Carries the per-brief standing rules (limits, no commit/push, quiet-machine timing, same-world bar, units) and a short procedure distilled from systematic- debugging/verification-before-completion (obra/superpowers) and ub-mode: count first, suspect the measurement, root cause before fix, one change at a time, attack the premise / stop after three failed fixes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-11-01 01:37:58 +01:00
Fr0zkaandClaude Opus 5.5	0065ee68e6	tools: per-strate density dispatch report in the fast tier (L132) --density-dispatch-report prints each strate's bound path and tile shares. Owner world: SW native heightfield; FI, TN, VS on compiled-analytic legacy fallback (FI lacks an imported FloatingIslandPlan; TN/VS have legacy recipes). A native FI candidate broke the composed owner walk/shell gates, so the owner stays on its path. Output unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-10-31 02:40:58 +01:00
Fr0zkaandClaude Opus 5.5	ebae71b142	research: R46 generator capability matrix (read-only) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-10-31 02:11:29 +01:00
Fr0zkaandClaude Opus 5.5	81071969fc	docs+cleanup: CURRENT-STATE.md and dead L86/L88 ablation switches removed (L131) One current-state page (shipping behaviour, references with sources, gaps, verification, closed lines), linked from CLAUDE.md. Removes the L86/L88 passage/boundary ablation switches and the unused legacy route-grade audit; inventory of every kept switch in the report. Output identical: 24/24 + 18/18 hashes, fast tier, walk/seam audits, UE host build; timing unchanged (-0.2%, CI spans 0). No Source/ changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-10-31 02:11:10 +01:00
Fr0zkaandClaude Opus 5.5	cbbfd46bd3	research: Astra low open project review — what to focus on now (read-only) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1	2026-10-31 01:19:41 +01:00