passages: four-strate passage floors supported (L67, evaluator v212); 1-2 wall beat still red

- Shared composer: a passage's restored support is applied after a physically overlapping
  later bore, instead of being carved away by it (0-1: 59 -> 0 unsupported).
- Capsule clearance for support restoration is tested against nearby route segments only
  (1-2: 3 -> 0, 2-3: 2 -> 0 unsupported).
- L66 index switches replaced by a physical criterion (both mouths inside their strata bands,
  neither a SurfaceWorld landing).
- Audit: floor zero-crossing refined by bisection (the 0.2498 m "step" was the gauge);
  wall ripple keeps the authored radius, cubic detrend per 32 m window. Controls detected:
  L35 ribs, beads, synthetic 0.25 m step, L36 washboard, L23 terrace.
- Result: 0-1 and 2-3 pass all audits; 1-2 fails wall ripple 7.27 cm (limit 3.5) from an
  authored-radius beat at 7.06 m. Fast tier was green before the final gauge change and was
  not re-run after it.

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

Standalone/Research/WorldAssemblerM3/Linux67/RunInterleavedWholeViewCostL67.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Measure three interleaved L66/L67 whole-view pairs for each owner strate."""
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l67/cost"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BASELINE = ROOT / "Saved/Linux/l67/bin-l66-baseline/VoxelForgeCoreHeadless-l67-l66-baseline-clang"
+CANDIDATE = ROOT / "Saved/Linux/l67/bin-final/VoxelForgeCoreHeadless-l67-final-clang"
+CAMERAS = {
+    0: "0.000000,0.000000,-374.939453,0.000000,0.000000",
+    1: "25.836914,3.199219,-737.000000,0.000000,0.000000",
+    2: "19.166016,-14.200195,-753.374023,0.000000,0.000000",
+    3: "-20.062500,-5.068359,-900.353516,0.000000,0.000000",
+}
+ORDER = ("l66", "l67", "l67", "l66", "l66", "l67")
+PREFIXES = (
+    "[PipelineFullDetailHash]", "[PipelineWholeViewHash]",
+    "[PipelineLODHash]", "[PipelineExactQueryHash]",
+)
+ELAPSED_RE = re.compile(r"\belapsed_ms=([0-9.]+)")
+WHOLE_VIEW_RE = re.compile(r"^\[StreamPipeline\].*?whole_view_ready=([0-9.]+)s", re.M)
+ENV = os.environ.copy()
+
+
+def run(strate, repetition, variant):
+    binary = BASELINE if variant == "l66" else CANDIDATE
+    name = f"strate{strate}-pair{repetition // 2 + 1}-{variant}"
+    log_path = OUT / f"{name}.log"
+    layout_path = OUT / f"{name}.json"
+    command = [
+        str(binary), str(DATA), "--workers=1", "--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={CAMERAS[strate]}",
+        f"--resolved-layout-output={layout_path}",
+    ]
+    wrapped = [
+        "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+        "timeout", "1800s", *command,
+    ]
+    start = time.monotonic()
+    with log_path.open("w", encoding="utf-8") as stream:
+        result = subprocess.run(wrapped, cwd=ROOT, env=ENV, stdout=stream,
+                                stderr=subprocess.STDOUT, timeout=1800, check=False)
+    elapsed = time.monotonic() - start
+    lines = log_path.read_text(encoding="utf-8", errors="replace").splitlines()
+    hashes = [line for line in lines if line.startswith(PREFIXES)]
+    pipeline_elapsed = [float(value) for line in lines
+        if line.startswith("[PipelineWholeViewHash]")
+        for value in ELAPSED_RE.findall(line)]
+    whole_view_match = WHOLE_VIEW_RE.search("\n".join(lines))
+    record = {
+        "strate": strate, "pair_order": repetition, "variant": variant,
+        "elapsed_seconds": elapsed, "pipeline_elapsed_ms": pipeline_elapsed,
+        "whole_view_seconds": float(whole_view_match.group(1))
+            if whole_view_match else None,
+        "exit_code": result.returncode, "hash_rows": len(hashes),
+        "log": str(log_path.relative_to(ROOT)),
+    }
+    print(json.dumps(record, sort_keys=True), flush=True)
+    return record
+
+
+def main():
+    OUT.mkdir(parents=True, exist_ok=True)
+    results = []
+    for strate in range(4):
+        for repetition, variant in enumerate(ORDER):
+            record = run(strate, repetition, variant)
+            results.append(record)
+            if record["exit_code"] != 0 or record["hash_rows"] != 12:
+                break
+        else:
+            continue
+        break
+    strata = {}
+    for strate in range(4):
+        values = {variant: [row["whole_view_seconds"] for row in results
+            if row["strate"] == strate and row["variant"] == variant
+            and row["whole_view_seconds"] is not None]
+            for variant in ("l66", "l67")}
+        if all(len(values[variant]) == 3 for variant in ("l66", "l67")):
+            l66 = sorted(values["l66"])[1]
+            l67 = sorted(values["l67"])[1]
+            strata[str(strate)] = {"l66_seconds": values["l66"],
+                "l67_seconds": values["l67"], "l66_median_seconds": l66,
+                "l67_median_seconds": l67,
+                "change_percent": (l67 / l66 - 1.0) * 100.0}
+    summary = {"pairs_per_strate": 3, "order": ORDER, "strata": strata,
+               "runs": results,
+               "complete": len(results) == 24
+                   and all(x["exit_code"] == 0 and x["hash_rows"] == 12
+                           for x in results)}
+    (OUT / "cost-summary.json").write_text(json.dumps(summary, indent=2) + "\n",
+        encoding="utf-8")
+    print(f"[L67CostSummary] complete={summary['complete']} runs={len(results)}",
+          flush=True)
+    return 0 if summary["complete"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())