passages: smooth 12 m lower-mouth radius taper; all four-strate passages pass (L68, v213)

The FI->TN wall beat (4.77 cm at 7.06 m) was the lower-mouth flare: the full mouth radius
was assigned to the penultimate control point, a one-segment radius jump. The shared route
builder now blends to the mouth radius over 12 m with a smoothstep. Wall ripple 1-2:
7.27 -> 1.62 cm. All three passages pass support/blocked/grade/ripple/naturalness; controls
detected. Fast tier 269/269 incl. the new-plan stage; W1/W8/W12 equal, Clang and GCC.
Hash pins: FI style 2 re-pinned at v213.

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

Standalone/Research/WorldAssemblerM3/Linux68/RunOwnerW1W8W12DeterminismL68.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Compare owner four-strata hashes at W1/W8/W12 with both compilers."""
+import json
+import re
+import subprocess
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l68"
+DATA = ROOT / "Standalone/data/owner_world.json"
+LAYOUT = OUT / "layouts/final-clang-owner.json"
+BINARIES = {
+    "clang": OUT / "bin-final-clang/VoxelForgeCoreHeadless-l68-final-clang",
+    "gcc": OUT / "bin-final-gcc/VoxelForgeCoreHeadless-l68-final-gcc",
+}
+HASH_RE = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
+RESULTS = []
+
+
+def hashes(path):
+    return HASH_RE.findall(path.read_text(encoding="utf-8", errors="replace"))
+
+
+def cameras_by_strate():
+    layout = json.loads(LAYOUT.read_text(encoding="utf-8"))
+    scale = float(layout["core_voxel_size_um"]) / 256_000_000.0
+    cameras = {}
+    for passage in layout["passages"]:
+        upper = str(int(passage["upper_strate_index"]))
+        lower = str(int(passage["lower_strate_index"]))
+        cameras.setdefault(upper, tuple(float(v) * scale for v in passage["upper_mouth_q"]))
+        cameras[lower] = tuple(float(v) * scale for v in passage["lower_mouth_q"])
+    if set(cameras) != {"0", "1", "2", "3"}:
+        raise RuntimeError(f"expected a camera for all four strata; found {sorted(cameras)}")
+    return cameras
+
+
+def main():
+    (OUT / "verify").mkdir(parents=True, exist_ok=True)
+    logs = OUT / "logs/determinism"
+    layouts = OUT / "layouts/determinism"
+    logs.mkdir(parents=True, exist_ok=True)
+    layouts.mkdir(parents=True, exist_ok=True)
+    cameras = cameras_by_strate()
+    for compiler, binary in BINARIES.items():
+        for strate in range(4):
+            camera = ",".join(f"{value:.6f}" for value in (*cameras[str(strate)], 0.0, 0.0))
+            outputs = {}
+            codes = {}
+            for workers in (1, 8, 12):
+                name = f"owner-new-plan-{compiler}-strate{strate}-w{workers}"
+                log_path = logs / f"{name}.log"
+                layout_path = layouts / f"{name}.json"
+                command = [
+                    "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+                    "timeout", "1740s", str(binary), str(DATA), f"--workers={workers}",
+                    "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+                    "--force-generate", "--clip-radius=1", "--max-clip-level=8",
+                    "--max-level=0", "--recipe=surface-world", "--stream-hash",
+                    "--max-clip-level=0", "--render-distance-chunks=0", f"--camera={camera}",
+                    f"--resolved-layout-output={layout_path}",
+                ]
+                with log_path.open("w", encoding="utf-8") as stream:
+                    result = subprocess.run(command, cwd=ROOT, stdout=stream,
+                        stderr=subprocess.STDOUT, timeout=1740, check=False)
+                outputs[workers] = hashes(log_path)
+                codes[workers] = result.returncode
+                print(json.dumps({"compiler": compiler, "strate": strate,
+                    "workers": workers, "exit_code": result.returncode,
+                    "hash_rows": len(outputs[workers]), "log": str(log_path.relative_to(ROOT))},
+                    sort_keys=True), flush=True)
+                if result.returncode != 0 or len(outputs[workers]) != 12:
+                    break
+            passed = (set(codes) == {1, 8, 12} and all(code == 0 for code in codes.values())
+                and outputs[1] == outputs[8] == outputs[12])
+            RESULTS.append({"compiler": compiler, "strate": strate,
+                "workers": {str(k): len(v) for k, v in outputs.items()},
+                "exit_codes": {str(k): v for k, v in codes.items()},
+                "w1_w8_w12_equal": passed})
+            if not passed:
+                break
+        if RESULTS[-1]["compiler"] != compiler or not RESULTS[-1]["w1_w8_w12_equal"]:
+            break
+    passed = len(RESULTS) == 8 and all(row["w1_w8_w12_equal"] for row in RESULTS)
+    summary = {"status": "PASS" if passed else "FAIL", "strata": RESULTS}
+    (OUT / "verify/owner-w1-w8-w12-determinism.json").write_text(
+        json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    print(f"[L68OwnerW1W8W12] status={summary['status']} rows={len(RESULTS)}", flush=True)
+    return 0 if passed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())