wip: cave planner squash-merged into wip/combined (L173, RED - not for main)

Five conflicts resolved (CURRENT-STATE, ResolvedLayoutInternal.h, StreamBenchmarkHeadless.cpp,
StreamBenchmarkPipeline.h, WorldAssemblyPrototype.h) keeping liminal + cave planner; L156 band fit only; evaluator v239
with v239 baselines (18/18 Clang/GCC W1/W8/W12). Fast tier FAILS (FI upper arrival: 40 unsupported chamber samples,
10 chamber-floor shell violations); TN and VS composed sweeps 0/16 (passage, seam, shell gates). Living plane loads at
PostConfigInit (UE smoke passes). Source/: VoxelForgeCoreAdapter.cpp; VoxelForge.uplugin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1

Standalone/Research/WorldAssemblerM3/Linux173/REPORT.md

@@ -0,0 +1,38 @@
+# L173 — combined branch verification and cave planner merge
+
+`wip/combined` builds and the Linux UE smoke run passes, but the branch is not ready to merge to `assembler/world`: fast is red and both composed cave sweeps finished at 0/16. The cave route planners and their blocked-route controls passed on all Vertical Shafts seeds; the remaining failures are in host passage composition, seams, and shell fit.
+
+## Merge and fixes
+
+Resolved all five textual conflicts in the worktree:
+
+- `CURRENT-STATE.md`: combined the cave planner history with the merged liminal, living-plane, speed, and early-admission state.
+- `Standalone/Core/src/ResolvedLayoutInternal.h`: retained the liminal lower-arrival tangent and the cave planner’s native route tangent.
+- `Standalone/Source/StreamBenchmarkHeadless.cpp`: retained liminal field detection and cave recipe selection.
+- `Standalone/Source/StreamBenchmarkPipeline.h`: retained the liminal road audit and cave chamber, tunnel, and shaft audits.
+- `Standalone/Source/WorldAssemblyPrototype.h`: retained the liminal `planPassages` guard and dispatched cave recipes to the Core planner.
+
+Applied only the band-fit portion of `Standalone/Research/WorldAssemblerM3/Linux156/l156-headroom-landing.patch`. No L153–L159 landing-pad experiment patch or stamp was applied. The merged fast check still fails on the Floating Islands upper arrival, with 40 unsupported chamber samples (lower chamber: 0), 10 chamber-floor shell violations, and 465 blocked strate-0 route samples. The route summary is walkable 1/3. The streaming mid-pass refill check passes.
+
+Three targeted edits for the same Floating Islands integration failure did not clear fast; they were reverted. I stopped further edits after the third failed attempt.
+
+The cave branch already carries `WorldAssemblyEvaluatorVersion=239` (the `wip/combined` base was 227). Canonical owner outputs changed, so added v239 baselines for owner4 SurfaceWorld, owner2 SurfaceWorld, and owner2 Floating Islands, and updated `verify.py` to use them. The matrix is 18/18, identical across Clang/GCC and W1/W8/W12. Owner4’s checked-in resolved-layout snapshot fails the stable-identity import check; the matrix regenerated the Core plan with `--seed=0`. This limits that result to the regenerated-plan path.
+
+## Builds and checks
+
+- Clang 19 and GCC 14 headless builds pass at source stamp `d62251e728397859bf8c258fbcee819909e65888b5fb5d14b6c0f3e00eee8695` (`Saved/Linux/l173/headless-clang-final.log`, `headless-gcc.log`).
+- Five liminal fixtures pass; the Living Plane standalone runner builds (`liminal-fixtures-build.log`, `living-plane-build.log`).
+- Fast rerun against the final-source binary fails after 65.2 seconds on `owner-floating-islands-style2-clang`; the refill check passes. A first rerun to a new output directory stopped because that directory had no compiled executable; the recorded result uses the existing final-source binary.
+- Linux UE full build passes with all three plugin links pointing to this worktree. `VoxelWorld.cpp` compiled, `VoxelForgeLivingPlane` linked, and the DWARF gate passed at 600 bytes for each of its three measured objects. Owner-world default-on smoke passed: 47 moving samples and 106 dwell samples over 52.789 seconds; frame-resolution arrival was 1.611817 seconds, early-admission wait was 0, tick p99 was 7.0801 ms, and worst tick was 12.272 ms. The harness restored all three VFHost links to the main checkout afterward. See `Saved/Linux/l173/ue/result.json` and `ue/restored-main-links.json`.
+- Tunnel Network composed sweep: **0/16**. Passage and seam gates failed on all 16; shell and passage-count failed on 10; the Tunnel Network route gate failed on one seed; blocked-route controls passed 16/16.
+- Vertical Shafts composed sweep: **0/16**. Passage and seam gates failed on all 16; shell and passage-count failed on 10. The Vertical Shafts route gate and blocked-route controls passed 16/16. Seed 2 specifically passes the shaft route and negative control; a strate-0 host route has five unsupported samples, leaving route walkability at 2/3. Its shell audit passes.
+
+The sweep summaries were regraded from captured logs with the current-source grader. Both are under `Saved/Linux/l173/cave-sweeps/seeds/`.
+
+## Not run and remaining risk
+
+- No Windows UE build was run. The owner should compile the changed Unreal source file `Source/VoxelForge/Private/VoxelForgeCoreAdapter.cpp`.
+- No performance timing matrix was run; the W1/W8/W12 matrix above checks canonical output identity.
+- Fast remains red, and neither composed sweep has an all-gates pass. The host content-band, route, seam, and chamber-floor failures need a root-cause fix before merging into `assembler/world`.
+
+No commit, push, or merge to `assembler/world` was made. Changes remain in the `wip/combined` worktree for review.

Standalone/Research/WorldAssemblerM3/Linux173/RunL173CanonicalHashes.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Compare owner canonical hashes across Clang/GCC and W1/W8/W12."""
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l173/canonical-hashes"
+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 = {
+    "clang": ROOT / "Saved/Linux/l173/fast/bin/VoxelForgeCoreHeadless-fast-clang",
+    "gcc": ROOT / "Saved/Linux/l173/bin/VoxelForgeCoreHeadless-l173-gcc",
+}
+BASELINES = {
+    ("owner2", "surface-world"): (
+        "owner-hash-surface-world-style1-v227.baseline",
+        "owner-hash-surface-world-style1-v237.baseline",
+        "owner-hash-surface-world-style1-v239.baseline"),
+    ("owner2", "floating-islands"): (
+        "owner-hash-floating-islands-style2-v227.baseline",
+        "owner-hash-floating-islands-style2-v237.baseline",
+        "owner-hash-floating-islands-style2-v239.baseline"),
+    ("owner4", "surface-world"): (
+        "owner-hash-owner4-surface-world-style1-v227.baseline",
+        "owner-hash-owner4-surface-world-style1-v239.baseline"),
+}
+BASELINE_ROOT = ROOT / "Standalone/Tools/verify/baselines/owner-hash/canonical"
+HASH_RE = re.compile(
+    r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
+STAMP_RE = re.compile(r"^\[VoxelForgeSourceStamp\] sha256=([0-9a-f]+)$", re.M)
+
+
+def main() -> int:
+    OUT.mkdir(parents=True, exist_ok=True)
+    stamp = subprocess.check_output(
+        [sys.executable, str(ROOT / "Standalone/Tools/verify/source_stamp.py"),
+         "stamp", "--root", str(ROOT)], text=True).strip()
+    baseline_hashes = {}
+    for key, filenames in BASELINES.items():
+        baseline_hashes[key] = {}
+        for filename in filenames:
+            path = BASELINE_ROOT / filename
+            if path.is_file():
+                baseline_hashes[key][filename] = HASH_RE.findall(
+                    path.read_text(encoding="utf-8", errors="replace"))
+
+    rows = []
+    groups = {}
+    partial = OUT / "runs-partial.json"
+    for dataset, recipes in RECIPES.items():
+        for recipe in recipes:
+            signatures = []
+            for workers in (1, 8, 12):
+                for compiler in ("clang", "gcc"):
+                    binary = BINARIES[compiler]
+                    label = f"{dataset}-{recipe}-{compiler}-w{workers}"
+                    log = OUT / f"{label}.log"
+                    layout = OUT / f"{label}.layout.json"
+                    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",
+                        f"--resolved-layout-output={layout}",
+                    ]
+                    # Rebuild owner4's Core plan from the same exported seed. Its checked-in
+                    # Unreal snapshot currently fails canonical import after the planner merge.
+                    if dataset == "owner4":
+                        command.append("--seed=0")
+                    started = time.monotonic()
+                    code: int | str
+                    try:
+                        with log.open("w", encoding="utf-8") as output:
+                            proc = subprocess.run(command, cwd=ROOT, stdout=output,
+                                stderr=subprocess.STDOUT, check=False, timeout=1740)
+                        code = proc.returncode
+                    except subprocess.TimeoutExpired:
+                        code = "OUTER_TIMEOUT"
+                    output = log.read_text(encoding="utf-8", errors="replace") \
+                        if log.is_file() else ""
+                    hashes = HASH_RE.findall(output)
+                    stamp_match = STAMP_RE.search(output)
+                    run_ok = (code == 0 and len(hashes) == 12 and stamp_match is not None
+                              and stamp_match.group(1) == stamp)
+                    row = {
+                        "dataset": dataset, "recipe": recipe, "compiler": compiler,
+                        "workers": workers, "seed_override": 0 if dataset == "owner4" else None,
+                        "exit_code": code, "run_passed": run_ok,
+                        "hashes": hashes,
+                        "source_stamp": stamp_match.group(1) if stamp_match else None,
+                        "elapsed_s": round(time.monotonic() - started, 3),
+                        "log": str(log.relative_to(ROOT)),
+                    }
+                    rows.append(row)
+                    signatures.append(row)
+                    print("[L173CanonicalHashRun] " + json.dumps(row, sort_keys=True),
+                          flush=True)
+                    partial.write_text(json.dumps(rows, indent=2) + "\n", encoding="utf-8")
+
+            expected = baseline_hashes[(dataset, recipe)]
+            first = signatures[0]["hashes"] if signatures else []
+            deterministic = (len(signatures) == 6
+                and all(row["run_passed"] and row["hashes"] == first
+                        for row in signatures))
+            baseline_matches = {
+                name: bool(first) and first == values
+                for name, values in expected.items()
+            }
+            groups[f"{dataset}/{recipe}"] = {
+                "all_compilers_workers_match": deterministic,
+                "hash_rows": len(first),
+                "baseline_matches": baseline_matches,
+                "source_stamp": stamp,
+            }
+            print("[L173CanonicalHashGroup] " + json.dumps(
+                {"group": f"{dataset}/{recipe}", **groups[f"{dataset}/{recipe}"]},
+                sort_keys=True), flush=True)
+
+    passed = (len(rows) == 18
+        and all(row["run_passed"] for row in rows)
+        and all(group["all_compilers_workers_match"] for group in groups.values()))
+    summary = {"status": "PASS" if passed else "FAIL", "source_stamp": stamp,
+        "runs": rows, "groups": groups}
+    (OUT / "summary.json").write_text(
+        json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    print(f"[L173CanonicalHashSummary] status={summary['status']} runs={len(rows)} "
+        f"groups={len(groups)}", flush=True)
+    return 0 if passed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Standalone/Research/WorldAssemblerM3/Linux173/RunL173CaveSeedSweep.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Run the composed Tunnel Network or Vertical Shafts gates for seeds 0..15."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l173/cave-sweeps/seeds"
+BIN = ROOT / "Saved/Linux/l173/fast/bin/VoxelForgeCoreHeadless-fast-clang"
+DATA = ROOT / "Standalone/data/owner_world.json"
+STAMP_TOOL = ROOT / "Standalone/Tools/verify/source_stamp.py"
+STAMP_RE = re.compile(r"^\[VoxelForgeSourceStamp\] sha256=([0-9a-f]+)$", re.M)
+DISPATCH = {
+    "tunnel-network": re.compile(
+        r"^\[DensityDispatch\] strate=2 generator=TunnelNetwork "
+        r"recipe=Core\.Caves\.PrimitiveField version=1 "
+        r"bound_path=Caves-native adapter=FCavesFieldAdapter$", re.M),
+    "vertical-shafts": re.compile(
+        r"^\[DensityDispatch\] strate=3 generator=VerticalShafts "
+        r"recipe=Core\.Caves\.PrimitiveField version=1 "
+        r"bound_path=Caves-native adapter=FCavesFieldAdapter$", re.M),
+}
+ROUTES = {
+    "tunnel-network": re.compile(
+        r"^\[ResolvedStrateRouteAudit\] strate=2 .*unsupported=0 "
+        r"grade_failures=0 .*status=PASS$", re.M),
+    "vertical-shafts": re.compile(
+        r"^\[ResolvedStrateRouteAudit\] strate=3 .*unsupported=0 "
+        r"grade_failures=0 .*status=PASS$", re.M),
+}
+CONTROLS = {
+    "tunnel-network": re.compile(
+        r"^\[TunnelNetworkBlockedRouteControl\].*expected=FAIL status=PASS$", re.M),
+    "vertical-shafts": re.compile(
+        r"^\[VerticalShaftsBlockedRouteControl\].*expected=FAIL status=PASS$", re.M),
+}
+REQUIRED = {
+    "passages": re.compile(r"^\[ResolvedPassageAuditSummary\].*status=PASS$", re.M),
+    "seams": re.compile(r"^\[PassageTileSeamAudit\].*status=PASS$", re.M),
+    "shell": re.compile(r"^\[PassageShellAuditSummary\].*status=PASS$", re.M),
+    "naturalness": re.compile(r"^\[PassageNaturalnessSummary\].*status=PASS$", re.M),
+    "mouth_profile": re.compile(r"^\[PassageMouthProfileSummary\].*status=PASS$", re.M),
+    "ripple": re.compile(r"^\[PassageRippleAuditSummary\].*status=PASS$", re.M),
+    "passage_interior": re.compile(
+        r"^\[PassageInteriorCapsuleAuditSummary\].*status=PASS$", re.M),
+}
+
+
+def evaluate_seed(kind: str, content: str, stamp: str, layout: Path) -> tuple[dict, str | None]:
+    stamp_match = STAMP_RE.search(content)
+    checks = {name: bool(pattern.search(content)) for name, pattern in REQUIRED.items()}
+    checks["source_stamp"] = stamp_match is not None and stamp_match.group(1) == stamp
+    checks["dispatch"] = bool(DISPATCH[kind].search(content))
+    checks["route"] = bool(ROUTES[kind].search(content))
+    checks["blocked_route_control"] = bool(CONTROLS[kind].search(content))
+    checks["three_passage_interiors"] = len(re.findall(
+        r"^\[ResolvedPassageAudit\].*interior_air=PASS", content, re.M)) == 3
+    checks["three_interior_negative_controls"] = len(re.findall(
+        r"^\[ResolvedPassageInteriorNegativeControl\].*detected=true status=PASS$",
+        content, re.M)) == 3
+    checks["three_ripple_gap_controls"] = len(re.findall(
+        r"^\[PassageRippleSamplingControl\].*status=PASS$", content, re.M)) == 3
+    checks["three_blocked_passage_controls"] = len(re.findall(
+        r"^\[ResolvedPassageBlockedControl\].*detected=true$", content, re.M)) == 3
+    checks["passage_count"] = len(re.findall(
+        r"^\[ResolvedPassageAudit\].*walkability=PASS$", content, re.M)) == 3
+    layout_identity = None
+    try:
+        checks["layout_output"] = layout.is_file()
+        if layout.is_file():
+            layout_identity = json.loads(layout.read_text(encoding="utf-8")).get(
+                "stable_identity")
+    except (OSError, json.JSONDecodeError):
+        checks["layout_output"] = False
+    return checks, layout_identity
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--kind", choices=tuple(DISPATCH), required=True)
+    parser.add_argument("--grade-only", action="store_true",
+                        help="regrade completed logs without rerunning the headless executable")
+    args = parser.parse_args()
+    if not BIN.is_file() or not DATA.is_file():
+        raise SystemExit("missing current Clang binary or composed owner fixture")
+    stamp = subprocess.check_output(
+        [sys.executable, str(STAMP_TOOL), "stamp", "--root", str(ROOT)], text=True).strip()
+    mode_out = OUT / args.kind
+    mode_out.mkdir(parents=True, exist_ok=True)
+    if args.grade_only:
+        partial = mode_out / "runs-partial.json"
+        previous = json.loads(partial.read_text(encoding="utf-8")) if partial.is_file() else []
+        by_seed = {int(row["seed"]): row for row in previous}
+        results = []
+        for seed in range(16):
+            log = mode_out / f"seed{seed}.log"
+            layout = mode_out / f"seed{seed}.json"
+            content = log.read_text(encoding="utf-8", errors="replace") \
+                if log.is_file() else ""
+            checks, identity = evaluate_seed(args.kind, content, stamp, layout)
+            code = by_seed.get(seed, {}).get("exit")
+            passed = code == 0 and all(checks.values())
+            failed_checks = [name for name, ok in checks.items() if not ok]
+            row = {"kind": args.kind, "seed": seed,
+                "verdict": "PASS" if passed else "FAIL",
+                "reason": ", ".join(failed_checks) if failed_checks else
+                    "all composed gates pass" if code == 0 else f"process exit {code}",
+                "exit": code, "checks": checks, "source_stamp": stamp,
+                "layout_identity": identity,
+                "log": str(log.relative_to(ROOT)), "layout": str(layout.relative_to(ROOT))}
+            results.append(row)
+        passed_count = sum(row["verdict"] == "PASS" for row in results)
+        summary = {"kind": args.kind, "source_stamp": stamp,
+            "grading_mode": "existing-captured-logs", "seeds": list(range(16)),
+            "passed": passed_count, "failed": 16 - passed_count, "results": results}
+        (mode_out / "runs-regraded.json").write_text(
+            json.dumps(results, indent=2) + "\n", encoding="utf-8")
+        (mode_out / "summary.json").write_text(
+            json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+        print(f"[L173CaveSeedSweepSummary] kind={args.kind} "
+            f"passed={passed_count}/16 failed={16-passed_count} "
+            f"status={'PASS' if passed_count == 16 else 'FAIL'} grading=existing-logs",
+            flush=True)
+        return 0 if passed_count == 16 else 1
+    results = []
+    partial = mode_out / "runs-partial.json"
+    for seed in range(16):
+        log = mode_out / f"seed{seed}.log"
+        layout = mode_out / f"seed{seed}.json"
+        command = [
+            "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+            "timeout", "1740s", str(BIN), str(DATA), "--world-assembler-prototype",
+            "--stream-benchmark", "--stream-pipeline", "--workers=8", "--clip-radius=3",
+            "--max-clip-level=8", "--max-level=0", "--force-generate", f"--seed={seed}",
+            "--recipe=surface-world", "--density-dispatch-report",
+            "--audit-resolved-layout-passages", "--audit-passage-tile-seams",
+            f"--resolved-layout-output={layout}",
+        ]
+        started = time.monotonic()
+        try:
+            with log.open("w", encoding="utf-8") as output:
+                proc = subprocess.run(command, cwd=ROOT, stdout=output,
+                    stderr=subprocess.STDOUT, check=False, timeout=1740)
+            code = proc.returncode
+        except subprocess.TimeoutExpired:
+            code = "OUTER_TIMEOUT"
+        content = log.read_text(encoding="utf-8", errors="replace") if log.exists() else ""
+        checks, layout_identity = evaluate_seed(args.kind, content, stamp, layout)
+        passed = code == 0 and all(checks.values())
+        failed_checks = [name for name, ok in checks.items() if not ok]
+        row = {
+            "kind": args.kind, "seed": seed, "verdict": "PASS" if passed else "FAIL",
+            "reason": ", ".join(failed_checks) if failed_checks else "all composed gates pass",
+            "exit": code, "checks": checks,
+            "source_stamp": stamp,
+            "layout_identity": layout_identity,
+            "elapsed_s": round(time.monotonic() - started, 3),
+            "log": str(log.relative_to(ROOT)), "layout": str(layout.relative_to(ROOT)),
+        }
+        results.append(row)
+        print("[L173CaveSeedSweep] " + json.dumps(row, sort_keys=True), flush=True)
+        partial.write_text(json.dumps(results, indent=2) + "\n", encoding="utf-8")
+    passed_count = sum(row["verdict"] == "PASS" for row in results)
+    summary = {"kind": args.kind, "source_stamp": stamp, "seeds": list(range(16)),
+        "passed": passed_count, "failed": 16 - passed_count, "results": results}
+    (mode_out / "summary.json").write_text(
+        json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    print(f"[L173CaveSeedSweepSummary] kind={args.kind} passed={passed_count}/16 "
+        f"failed={16-passed_count} status={'PASS' if passed_count == 16 else 'FAIL'}", flush=True)
+    return 0 if passed_count == 16 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

Standalone/Research/WorldAssemblerM3/Linux173/RunL173UE.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Build the combined tree in VFHost, verify DWARF/module output, and smoke the owner world."""
+from __future__ import annotations
+
+import importlib.util
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import sys
+
+
+ROOT = Path(__file__).resolve().parents[4]
+SAVED = ROOT / "Saved/Linux/l173"
+RUNNER_PATH = ROOT / "Standalone/Research/WorldAssemblerM3/Linux172/RunL172Movement.py"
+
+
+def load_l172_runner():
+    spec = importlib.util.spec_from_file_location("l172_runner", RUNNER_PATH)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"could not load L172 harness: {RUNNER_PATH}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    module.ROOT = ROOT
+    module.OUT = SAVED
+    module.UE_OUT = SAVED / "ue"
+    module.BUILD_OUT = SAVED / "ue/builds"
+    module.BIN_OUT = SAVED / "ue/bin"
+    return module
+
+
+def write_json(path: Path, value) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n",
+                         encoding="utf-8")
+    temporary.replace(path)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reuse-prior-build", action="store_true",
+                        help="verify the successful full build already logged in Saved/Linux/l173")
+    options = parser.parse_args()
+    SAVED.mkdir(parents=True, exist_ok=True)
+    runner = load_l172_runner()
+    result = {"plugin_root": str(ROOT.resolve())}
+    try:
+        build_log = SAVED / "ue/builds/ubt-l173-combined.log"
+        if options.reuse_prior_build:
+            if not build_log.is_file():
+                raise RuntimeError(f"prior full build log is missing: {build_log}")
+            restored = json.loads((SAVED / "ue/restored-main-links.json").read_text(
+                encoding="utf-8"))
+            archive_roots = set()
+            for item in restored.get("intermediates_moved", []):
+                moved = Path(item["to"])
+                if moved.name == "VoxelForge" and "External" in moved.parts:
+                    external_index = moved.parts.index("External")
+                    archive_roots.add(Path(*moved.parts[:external_index]))
+            archive_roots = [path for path in archive_roots
+                             if (path / "External/Build/Linux/x64/UnrealEditor/Development/"
+                                 "VoxelForge/VoxelWorld.cpp.o").is_file()]
+            if len(archive_roots) != 1:
+                raise RuntimeError(f"expected one archived combined-tree intermediate set: "
+                                   f"{archive_roots}")
+            runner.INTERMEDIATE = archive_roots[0]
+            dwarf = runner.dwarf_pre_run_gate()
+            runner.INTERMEDIATE = runner.HOST / "Intermediate"
+            build = {
+                **runner.root_info(ROOT),
+                "build_log": str(build_log),
+                "compiled_voxel_world_cpp": True,
+                "dwarf_pre_run_gate": dwarf,
+                "binary": str(SAVED / "ue/bin/l173-combined/"
+                              "libUnrealEditor-VoxelForge.so"),
+                "binary_sha256": runner.sha256_file(
+                    SAVED / "ue/bin/l173-combined/libUnrealEditor-VoxelForge.so"),
+                "reused_prior_full_build": True,
+            }
+        else:
+            build = runner.build_tree(ROOT, "l173-combined")
+        output = build_log.read_text(encoding="utf-8", errors="replace")
+        if ("Result: Succeeded" not in output
+                or re.search(r"\[\d+/\d+\] Compile VoxelWorld\.cpp", output) is None):
+            raise RuntimeError(f"UE build log lacks a successful VoxelWorld.cpp compile: {build_log}")
+        actor_compiled = re.search(r"Compile .*VoxelForgeLivingPlaneActor\.cpp", output) is not None
+        module_binary = (runner.HOST / "Binaries/Linux/"
+                         "libUnrealEditor-VoxelForgeLivingPlane.so")
+        if not actor_compiled or not module_binary.is_file():
+            raise RuntimeError(
+                "UE build did not compile/link the Living Plane module: "
+                f"actor_compiled={actor_compiled}, module_binary={module_binary.is_file()}; "
+                f"log={build_log}")
+        build["living_plane_actor_compiled"] = actor_compiled
+        build["living_plane_module_binary"] = str(module_binary.resolve())
+        result["build"] = build
+        write_json(SAVED / "ue/build.json", result)
+
+        shader_link = runner.HOST_PLUGIN_LINK / "Shaders"
+        if shader_link.exists() or shader_link.is_symlink():
+            if shader_link.resolve(strict=True) != (ROOT / "Shaders").resolve(strict=True):
+                raise RuntimeError(f"unexpected existing shader link target: {shader_link}")
+            created_shader_link = False
+        else:
+            temporary = shader_link.with_name(f"Shaders.l173-{os.getpid()}.tmp")
+            temporary.symlink_to(ROOT / "Shaders")
+            os.replace(temporary, shader_link)
+            created_shader_link = True
+
+        smoke = runner.run_trial(
+            "owner-world-smoke", "owner-world-smoke", "default-on", ROOT,
+            Path(build["binary"]), runner.WAIT_ON, runner.APPLY_ON_MS,
+            include_switch_overrides=False)
+        write_json(SAVED / "ue/owner-world-smoke.json", smoke)
+        result["smoke"] = smoke
+        write_json(SAVED / "ue/result.json", result)
+        print("[L173UE] BUILD PASS VoxelWorld.cpp=compiled "
+              "VoxelForgeLivingPlane=linked DWARF=PASS", flush=True)
+        print("[L173UE] OWNER_WORLD_SMOKE PASS "
+              + json.dumps({key: smoke[key] for key in (
+                  "frame_resolution_arrival_s", "tick_p99_ms", "tick_worst_ms",
+                  "early_admission_wait_for_critical", "early_admission_apply_budget_ms")},
+                  sort_keys=True), flush=True)
+        return 0
+    finally:
+        restored = runner.restore_main_checkout()
+        shader_link = runner.HOST_PLUGIN_LINK / "Shaders"
+        if locals().get("created_shader_link", False):
+            shader_link.unlink(missing_ok=True)
+        write_json(SAVED / "ue/restored-main-links.json", {
+            "main_root": str(runner.MAIN_CHECKOUT.resolve()),
+            "links": restored["links"],
+            "intermediates_moved": restored["intermediates_moved"],
+        })
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())