core: chamber floors planned into the passage h(s) profile (L152, v239; surface landing support open)

Seed 2 planned grades 9.58/6.58/8.28 deg (were 19 deg); 0 solid in 320,355 passage interior samples; 0 shell,
chamber, wall violations; envelope audit clean. Open: the upper Surface World landing plane, fitted to the surface
route, leaves 5 route + 2 chamber support samples unsupported.

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

Standalone/Research/WorldAssemblerM3/Linux152/RunL152Timing.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""L80 comparison of L152 with the assembler/world baseline."""
+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/l152/timing"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BINARIES = {
+    "assembler-world": (
+        ROOT / "Saved/Linux/l137/bin/VoxelForgeCoreHeadless-l137-aa-a",
+        "4499fb2a8a4ede7d6cbc68d1b794f104658cdaae93ed9cacbc91fe7ff3fc3621"),
+    "planner-head": (
+        ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-l152-clang",
+        "b299076d814ff7cc098aa373cdc3a26533ed8bfe1ef6df1ea9de4d400d231b25"),
+}
+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.compile(r"^\[StreamPipeline\] (.*)$", re.M)
+FIELDS = re.compile(r"([a-zA-Z0-9_]+)=([^ ]+)")
+NEAR = re.compile(
+    r"^\[WorldAssemblerNearLODReady\] lods=0-2 tiles=(\d+)/(\d+) cold_ready_s=([0-9.]+)$",
+    re.M)
+STAMP = re.compile(r"^\[VoxelForgeSourceStamp\] sha256=([0-9a-f]+)$", re.M)
+
+
+def run(strate: int, workers: int, version: str, phase: str, replicate: int) -> dict:
+    OUT.mkdir(parents=True, exist_ok=True)
+    binary, expected_stamp = BINARIES[version]
+    camera = ",".join(f"{value:.12f}" for value in CAMERAS[strate]) + ",0,0"
+    label = f"s{strate}-w{workers}-{version}-{phase}{replicate}"
+    log = OUT / f"{label}.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}", "--profile-lod-work", "--stream-scheduler-policy=3",
+    ]
+    started = time.monotonic()
+    with log.open("w", encoding="utf-8") as output:
+        proc = 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, stamp = PIPELINE.search(content), NEAR.search(content), STAMP.search(content)
+    if (proc.returncode or pipeline is None or near is None or stamp is None
+            or stamp.group(1) != expected_stamp):
+        raise SystemExit(f"L80 timing failed or source stamp mismatch: {log}; exit={proc.returncode}")
+    fields = dict(FIELDS.findall(pipeline.group(1)))
+    row = {
+        "strate": strate, "workers": workers, "version": version,
+        "phase": phase, "replicate": replicate, "source_stamp": stamp.group(1),
+        "lod02_ready_s": float(near.group(3)),
+        "whole_view_ready_s": float(fields["whole_view_ready"].removesuffix("s")),
+        "whole_tiles": int(fields["whole_tiles"].split("/")[0]),
+        "wall_s": round(time.monotonic() - started, 3),
+        "log": str(log.relative_to(ROOT)),
+    }
+    print("[L152TimingRun] " + 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]
+
+    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, *(entry[0] for entry in BINARIES.values())]):
+        raise SystemExit("missing L152 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"[L152TimingGate] load_1m={load_1m:.2f} cpu_idle_2s={idle:.1f}%", flush=True)
+    if load_1m >= 1.5 or idle < 97.0:
+        raise SystemExit("timing refused: machine is above the L80 quiet-load gate")
+
+    rows = []
+    versions = tuple(BINARIES)
+    for strate in range(4):
+        for workers in (8, 12):
+            for version in versions:
+                run(strate, workers, version, "warmup", 0)
+            for replicate in range(1, 6):
+                order = versions if replicate % 2 else tuple(reversed(versions))
+                for version in order:
+                    rows.append(run(strate, workers, version, "measured", replicate))
+                    (OUT / "runs-partial.json").write_text(
+                        json.dumps(rows, indent=2) + "\n", encoding="utf-8")
+
+    measured = [row for row in rows if row["phase"] == "measured"]
+    summary = []
+    for strate in range(4):
+        for workers in (8, 12):
+            group = [row for row in measured
+                     if row["strate"] == strate and row["workers"] == workers]
+            medians = {
+                version: {
+                    key: statistics.median(row[key] for row in group
+                                           if row["version"] == version)
+                    for key in ("lod02_ready_s", "whole_view_ready_s")
+                }
+                for version in versions
+            }
+            entry = {"strate": strate, "workers": workers,
+                     "replicates_per_version": 5, "medians": medians}
+            for key in ("lod02_ready_s", "whole_view_ready_s"):
+                entry[f"planner_head_vs_assembler_world_{key}_delta_pct"] = round(
+                    100.0 * (medians["planner-head"][key]
+                             / medians["assembler-world"][key] - 1.0), 2)
+                entry[f"{key}_paired_deltas_pct"] = [
+                    round(100.0 * (
+                        next(row[key] for row in group
+                             if row["version"] == "planner-head"
+                             and row["replicate"] == replicate)
+                        / next(row[key] for row in group
+                               if row["version"] == "assembler-world"
+                               and row["replicate"] == replicate) - 1.0), 3)
+                    for replicate in range(1, 6)]
+            summary.append(entry)
+    (OUT / "summary.json").write_text(json.dumps({
+        "a_a_noise_floor_pct": 1.0,
+        "timing_protocol": (
+            "one warm-up per binary, five interleaved runs per cell, W8/W12, "
+            "all four owner layers; L137 A/A median noise floor ±1%"),
+        "runs": rows,
+        "summary": summary,
+    }, indent=2) + "\n", encoding="utf-8")
+    failed_cells = []
+    for entry in summary:
+        for measure in ("lod02_ready_s", "whole_view_ready_s"):
+            delta = entry[f"planner_head_vs_assembler_world_{measure}_delta_pct"]
+            if delta > 1.0:
+                failed_cells.append({"strate": entry["strate"],
+                                     "workers": entry["workers"],
+                                     "measure": measure, "delta_pct": delta})
+    report = json.loads((OUT / "summary.json").read_text(encoding="utf-8"))
+    report["performance_floor_pct"] = 1.0
+    report["performance_floor_rule"] = (
+        "pass when no L152 median is more than 1% slower than assembler/world")
+    report["performance_floor_failures"] = failed_cells
+    report["status"] = "PASS" if not failed_cells else "FAIL"
+    (OUT / "summary.json").write_text(json.dumps(report, indent=2) + "\n",
+                                      encoding="utf-8")
+    print(f"[L152TimingSummary] cells={len(summary)} failing_metrics={len(failed_cells)} "
+          f"status={'PASS' if not failed_cells else 'FAIL'}", flush=True)
+    return 0 if not failed_cells else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())