wip(assembler): round L34 -- passage mouth profile audit and standard capture set

Adds a density-field floor/wall profile audit along passages near mouths (0.125 m spacing; L23
terraced negative control detected) and a reusable 12-view passage capture set (80 deg FOV, eye
height, LOD0, skirts off, capped clip planes). The old blurry mouth shot was camera framing; the
L33 entry ledges were tile skirts. Owner world hashes unchanged; 24/24 passage rows, 30/30
determinism, 16/16 invariants; cost within noise.

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

Standalone/Research/WorldAssemblerM3/Linux34/RunUpperFixtureDeterminismL34.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Rerun the upper-SW fixture's six L34 determinism cases and merge results."""
+import csv
+import re
+import subprocess
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l34"
+FIXTURE = ROOT / "Saved/Linux/l33/fixtures/sw-upper-tunnel-network-style0.json"
+BINARIES = {
+    "clang": OUT / "bin/VoxelForgeCoreHeadless-l34-clang",
+    "gcc": OUT / "bin/VoxelForgeCoreHeadless-l34-gcc",
+}
+LAYOUT_PATTERN = re.compile(
+    r"^\[ResolvedLayoutSnapshot\] schema=\d+ stable_identity=([^ ]+) strata=\d+ bytes=\d+ round_trip=PASS$",
+    re.M)
+PLAN_PATTERN = re.compile(
+    r"^\[WorldAssemblerPlanSerialization\].*canonical_round_trip=true .*"
+    r"plan_hash=([0-9a-f]+) manifest_hash=([0-9a-f]+) status=PASS$", re.M)
+ROUTE_PATTERN = re.compile(
+    r"^\[WorldAssemblerRouteAccepted\] arrival_xy_m=\([^)]*\) "
+    r"departure_xy_m=\([^)]*\) endpoint_proximity_cost=\d+ average_grade_q16=\d+$", re.M)
+rows = []
+failed = False
+reference = None
+
+for compiler, binary in BINARIES.items():
+    for workers in (1, 8, 12):
+        name = f"upper-fixture-{compiler}-w{workers}"
+        logfile = OUT / f"determinism-{name}.log"
+        command = [
+            "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+            "timeout", "1800s", str(binary), str(FIXTURE), f"--workers={workers}",
+            "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+            "--force-generate", "--clip-radius=3", "--max-clip-level=8", "--max-level=-1",
+            "--recipe=floating-islands", "--audit-resolved-layout-passages",
+        ]
+        started = time.monotonic()
+        try:
+            with logfile.open("w", encoding="utf-8") as stream:
+                result = subprocess.run(command, cwd=ROOT, stdout=stream,
+                    stderr=subprocess.STDOUT, timeout=1800, check=False)
+        except subprocess.TimeoutExpired:
+            result = None
+        elapsed = time.monotonic() - started
+        output = logfile.read_text(encoding="utf-8", errors="replace")
+        layouts = LAYOUT_PATTERN.findall(output)
+        plans = PLAN_PATTERN.findall(output)
+        routes = ROUTE_PATTERN.findall(output)
+        stamps = re.findall(
+            r"^\[WorldAssemblerRecipeAudit\] requested=([^ ]+) actual=([^ ]+).*status=([^ ]+)$",
+            output, re.M)
+        passage = re.search(r"^\[ResolvedPassageAuditSummary\].*status=PASS$", output, re.M)
+        signature = (tuple(layouts), tuple(plans), tuple(routes))
+        stable = reference is None or signature == reference
+        if reference is None and layouts and plans and routes:
+            reference = signature
+        ok = (result is not None and result.returncode == 0 and len(layouts) == 1
+              and len(plans) == 1 and len(routes) == 1
+              and stamps == [("floating-islands", "floating-islands", "PASS")]
+              and passage is not None and stable)
+        code = result.returncode if result is not None else "TIMEOUT"
+        rows.append(("upper-fixture", "floating-islands", compiler, workers,
+                     elapsed, code, ok))
+        failed |= not ok
+        print(f"[L34FixtureDeterminism] compiler={compiler} workers={workers} "
+              f"elapsed={elapsed:.1f}s recipe_stamp={stamps[0][1] if stamps else 'MISSING'} "
+              f"layout={layouts[0] if layouts else 'MISSING'} "
+              f"stable_across_matrix={'yes' if stable else 'no'} "
+              f"{'PASS' if ok else 'FAIL'}", flush=True)
+
+fixture_summary = OUT / "determinism-upper-fixture-l34.csv"
+with fixture_summary.open("w", newline="", encoding="utf-8") as stream:
+    writer = csv.writer(stream)
+    writer.writerow(("kind", "recipe", "compiler", "workers", "elapsed_seconds",
+                     "exit_code", "status"))
+    for row in rows:
+        writer.writerow((*row[:-1], f"{row[-1] and 'PASS' or 'FAIL'}"))
+
+combined = OUT / "determinism-l34.csv"
+with combined.open("r", newline="", encoding="utf-8") as stream:
+    owner_rows = list(csv.reader(stream))
+if owner_rows and owner_rows[0] == ["kind", "recipe", "compiler", "workers",
+                                     "elapsed_seconds", "exit_code", "status"]:
+    owner_rows = [row for row in owner_rows[1:] if row and row[0] != "upper-fixture"]
+else:
+    raise SystemExit("owner determinism summary is missing or malformed")
+if len(owner_rows) != 24:
+    raise SystemExit(f"expected 24 owner rows before fixture merge, found {len(owner_rows)}")
+with combined.open("w", newline="", encoding="utf-8") as stream:
+    writer = csv.writer(stream)
+    writer.writerow(("kind", "recipe", "compiler", "workers", "elapsed_seconds",
+                     "exit_code", "status"))
+    writer.writerows(owner_rows)
+    for row in rows:
+        writer.writerow((*row[:-1], f"{row[-1] and 'PASS' or 'FAIL'}"))
+
+print(f"[L34FixtureDeterminismSummary] runs={len(rows)} pass={sum(row[-1] for row in rows)} "
+      f"fail={sum(not row[-1] for row in rows)} combined_runs=30 "
+      f"combined_summary={combined} fixture_summary={fixture_summary}", flush=True)
+raise SystemExit(1 if failed or len(rows) != 6 else 0)