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/CaptureOwnerPassagesL67.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""Render arrival, departure, and mid-tunnel views for the four-strate owner plan."""
+import json
+import importlib.util
+import argparse
+import math
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l67/captures-run"
+BIN = ROOT / "Saved/Linux/l67/bin-final"
+CAPTURES = Path(__file__).resolve().parent / "captures"
+HEADLESS = BIN / "VoxelForgeCoreHeadless-l67-final-clang"
+RENDERER = BIN / "VoxelForgeOffscreenCapture-l67-final-clang"
+PNG_DIR = OUT / "capture-png"
+RECIPE_INPUTS = (
+    ("passage-0-1", ROOT / "Standalone/data/owner_world.json",
+     "surface-world", "SurfaceWorld", "upper"),
+    ("passage-1-2", ROOT / "Standalone/data/owner_world.json",
+     "surface-world", "FloatingIslands", "upper"),
+    ("passage-2-3", ROOT / "Standalone/data/owner_world.json",
+     "surface-world", "TunnelNetwork", "upper"),
+)
+SUBVOXELS_PER_VOXEL = 256.0
+RING_AUDIT = ROOT / "Standalone/Research/WorldAssemblerM3/Linux32/AuditRingTerraceL32.py"
+spec = importlib.util.spec_from_file_location("ring_profile_l32", RING_AUDIT)
+ring_profile = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(ring_profile)
+
+for directory in (OUT, BIN, PNG_DIR, CAPTURES):
+    directory.mkdir(parents=True, exist_ok=True)
+ENV = os.environ.copy()
+ENV["LP_NUM_THREADS"] = "12"
+ENV["XDG_CACHE_HOME"] = str(OUT / "xdg-cache")
+PARSER = argparse.ArgumentParser(description=__doc__)
+PARSER.add_argument("--scene", choices=[value[0] for value in RECIPE_INPUTS])
+PARSER.add_argument("--view", choices=("arrival-mouth", "departure-mouth", "mid-tunnel"))
+OPTIONS = PARSER.parse_args()
+
+
+def run(name, command):
+    log = OUT / f"capture-{name}.log"
+    wrapped = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+               "timeout", "1800s", *map(str, command)]
+    started = time.monotonic()
+    with log.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() - started
+    print(f"[L35CaptureRun] step={name} elapsed={elapsed:.1f}s exit={result.returncode} log={log}",
+          flush=True)
+    if result.returncode != 0:
+        raise SystemExit(f"{name} failed; see {log}")
+    return log
+
+
+def add(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+
+
+def sub(a, b):
+    return tuple(x - y for x, y in zip(a, b))
+
+
+def mul(a, scale):
+    return tuple(x * scale for x in a)
+
+
+def norm(a):
+    length = math.sqrt(sum(x * x for x in a))
+    if length <= 1.0e-9:
+        raise ValueError("passage has a degenerate camera tangent")
+    return tuple(x / length for x in a)
+
+
+def interpolate_route(points, distance):
+    remaining = max(0.0, distance)
+    for a, b in zip(points, points[1:]):
+        delta = sub(b[0], a[0])
+        length = math.sqrt(sum(x * x for x in delta))
+        if length <= 1.0e-9:
+            continue
+        if remaining <= length:
+            t = remaining / length
+            pos = tuple(a[0][axis] + delta[axis] * t for axis in range(3))
+            radius = a[1] + (b[1] - a[1]) * t
+            return pos, radius
+        remaining -= length
+    return points[-1]
+
+
+def route_frame(points, distance):
+    center, radius = interpolate_route(points, distance)
+    before, _ = interpolate_route(points, max(0.0, distance - 0.25))
+    after, _ = interpolate_route(points, distance + 0.25)
+    tangent = norm(sub(after, before))
+    horizontal = norm((tangent[0], tangent[1], 0.0))
+    side = (-horizontal[1], horizontal[0], 0.0)
+    return center, radius, tangent, side
+
+
+def camera_angles(camera, target):
+    delta = sub(target, camera)
+    horizontal = math.hypot(delta[0], delta[1])
+    yaw = math.degrees(math.atan2(delta[0], delta[1]))
+    pitch = math.degrees(math.atan2(delta[2], horizontal))
+    return yaw, pitch
+
+
+def fmt(values):
+    return ",".join(f"{value:.6f}" for value in values)
+
+
+def load_reference_cameras():
+    log = ROOT / "Saved/Linux/l34/run-capture-standard-set-final-radius3.log"
+    pattern = re.compile(
+        r"^\[L34CaptureCamera\] view=(\S+).*?camera_m=\(([^)]*)\) "
+        r"target_m=\(([^)]*)\) clip=(\S+)", re.M)
+    values = {}
+    for name, camera, target, clip in pattern.findall(
+            log.read_text(encoding="utf-8", errors="replace")):
+        parse = lambda value: tuple(float(part) for part in value.split(","))
+        values[name] = (parse(camera), parse(target), None if clip == "none" else parse(clip))
+    return values
+
+
+REFERENCE_CAMERAS = {}
+
+
+def terrain_surface_near(mesh, x, y, expected_height):
+    bounds = (x - 2.0, x + 2.0, y - 2.0, y + 2.0)
+    _, triangles, _ = ring_profile.read_scene(
+        str(mesh), None, -1.0e9, 1.0e9, bounds)
+    buckets = ring_profile.build_buckets(triangles, True, bounds, cell_size=1.0)
+    hits = []
+    for dy in range(-4, 5):
+        for dx in range(-4, 5):
+            sample_x, sample_y = x + dx * 0.5, y + dy * 0.5
+            hit = ring_profile.sample_surface(buckets, sample_x, sample_y, True, 1.0,
+                                              preferred_height=expected_height)
+            if hit is not None:
+                hits.append((math.hypot(dx * 0.5, dy * 0.5),
+                             abs(hit[0] - expected_height), sample_x, sample_y, hit[0]))
+    if not hits:
+        return None
+    distance, _, sample_x, sample_y, height = min(hits)
+    if distance > 2.0 or abs(height - expected_height) > 8.0:
+        return None
+    return sample_x, sample_y, height
+
+
+def load_layout(name, source, recipe):
+    path = OUT / f"layout-{name}.json"
+    run(f"layout-{name}", [HEADLESS, source, "--workers=12", "--world-assembler-prototype",
+        "--stream-benchmark", "--stream-pipeline", "--force-generate", "--clip-radius=2",
+        "--max-clip-level=0", "--max-level=0", f"--recipe={recipe}",
+        f"--resolved-layout-output={path}", "--resolved-layout-only"])
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def select_passage(layout, mouth_generator, preferred_side):
+    strata = {int(value["strate_index"]): value for value in layout["strates"]}
+    preferred_candidates = []
+    fallback_candidates = []
+    for passage in layout["passages"]:
+        upper = strata[int(passage["upper_strate_index"])]
+        lower = strata[int(passage["lower_strate_index"])]
+        sides = []
+        if upper["generator_kind"] == mouth_generator:
+            sides.append("upper")
+        if lower["generator_kind"] == mouth_generator:
+            sides.append("lower")
+        if preferred_side in sides:
+            preferred_candidates.append((passage, preferred_side == "lower"))
+        elif sides:
+            fallback_candidates.append((passage, sides[0] == "lower"))
+    candidates = preferred_candidates or fallback_candidates
+    if not candidates:
+        raise RuntimeError(f"no passage mouth in generator {mouth_generator}")
+    return sorted(candidates, key=lambda item: item[0]["stable_id"])[0]
+
+
+def make_views(layout, passage, reverse):
+    q_to_m = layout["core_voxel_size_um"] / (SUBVOXELS_PER_VOXEL * 1_000_000.0)
+    controls = [
+        (tuple(value * q_to_m for value in point["position_q"]),
+         point["radius_q"] * q_to_m)
+        for point in passage["control_points"]
+    ]
+    lower_mouth = tuple(value * q_to_m for value in passage["lower_mouth_q"])
+    lower_index = min(range(len(controls)), key=lambda i: sum(
+        (controls[i][0][axis] - lower_mouth[axis]) ** 2 for axis in range(3)))
+    path = controls[:lower_index + 1]
+    if len(path) < 2:
+        raise RuntimeError(f"{passage['stable_id']} has no mouth-to-mouth route")
+    if reverse:
+        path.reverse()
+    lengths = [math.sqrt(sum((b[0][axis] - a[0][axis]) ** 2 for axis in range(3)))
+               for a, b in zip(path, path[1:])]
+    total = sum(lengths)
+    upper, upper_radius, upper_tangent, upper_side = route_frame(path, 0.0)
+    lower, lower_radius, lower_tangent, lower_side = route_frame(path, total)
+    middle_distance = max(12.0, min(total - 12.0, total * 0.4)) if total > 24.0 else total * 0.4
+    entry_distance = min(6.0, total * 0.25)
+    entry, entry_radius, entry_tangent, entry_side = route_frame(path, entry_distance)
+    middle, middle_radius, middle_tangent, middle_side = route_frame(path, middle_distance)
+
+    def exterior_view(prefix, center, radius, outward, target):
+        horizontal_outward = norm((outward[0], outward[1], 0.0))
+        eye_height = center[2] - radius + 1.6
+        eye = (center[0] + horizontal_outward[0] * 5.5,
+               center[1] + horizontal_outward[1] * 5.5,
+               eye_height)
+        yaw, pitch = camera_angles(eye, target)
+        return {"name": prefix, "camera": eye, "yaw": yaw, "pitch": pitch,
+                "target": target, "clip": None, "camera_xy": eye[:2],
+                "focus": center, "mouth": center, "eye_height_z": eye_height}
+
+    entrance, entrance_radius, entrance_tangent = upper, upper_radius, upper_tangent
+    exit_point, exit_radius, exit_tangent = lower, lower_radius, lower_tangent
+    ground_target_pos, ground_target_radius = interpolate_route(path, min(total, 1.0))
+    ground = exterior_view("ground-mouth", entrance, entrance_radius,
+        mul(entrance_tangent, -1.0), (ground_target_pos[0], ground_target_pos[1],
+            ground_target_pos[2] - ground_target_radius + 1.0))
+    ground["focus"] = entrance
+    ground["outside_camera"] = True
+
+    def cutaway_view(prefix, center, radius, tangent, side, distance, target_distance):
+        camera = (center[0] - side[0] * 7.0, center[1] - side[1] * 7.0,
+                  center[2] - radius + 1.6)
+        target_pos, target_radius = interpolate_route(path, target_distance)
+        target = (target_pos[0], target_pos[1],
+                  target_pos[2] - target_radius + 1.6)
+        yaw, pitch = camera_angles(camera, target)
+        plane = (side[0], side[1], 0.0,
+                 -(side[0] * center[0] + side[1] * center[1]))
+        return {"name": prefix, "camera": camera, "yaw": yaw, "pitch": pitch,
+                "target": target, "clip": plane, "camera_xy": camera[:2],
+                "focus": center, "mouth": center}
+
+    # Place each interface view at its true route endpoint. The endpoint camera
+    # is a side cutaway so the solid terrain in front of an underground mouth
+    # cannot hide the floor-to-tunnel connection.
+    arrival_distance = 0.0
+    arrival_center, arrival_radius, arrival_tangent, arrival_side = route_frame(
+        path, arrival_distance)
+    arrival = cutaway_view("arrival", arrival_center, arrival_radius,
+        arrival_tangent, arrival_side, arrival_distance,
+        min(total, arrival_distance + 12.0))
+    arrival["camera_location"] = "passage-air"
+    arrival["focus_radius"] = 20.0
+    arrival["yaw"], arrival["pitch"] = camera_angles(
+        arrival["camera"], arrival["target"])
+
+    entry_camera_distance = min(8.0, total * 0.1)
+    entry_center, entry_radius, entry_tangent, entry_side = route_frame(
+        path, entry_camera_distance)
+    # Player-height view from just inside the passage, aimed through its actual
+    # interface mouth so the floor, bore, and opening share one frame.
+    entry_camera = (entry_center[0], entry_center[1],
+        entry_center[2] - entry_radius + 1.6)
+    entry_target_pos, entry_target_radius = interpolate_route(
+        path, min(total, entry_distance + 14.0))
+    entry_target = (entry_target_pos[0], entry_target_pos[1],
+        entry_camera[2] - 2.5)
+    entry_yaw, entry_pitch = camera_angles(entry_camera, entry_target)
+    entry_view = {"name": "rock-entry", "camera": entry_camera,
+        "yaw": entry_yaw, "pitch": entry_pitch, "target": entry_target,
+        "clip": None, "camera_xy": entry_camera[:2],
+        "focus": entry_center, "mouth": entrance, "outside_camera": False,
+        "camera_location": "passage-air", "focus_radius": 20.0,
+        "eye_height_z": entry_camera[2]}
+    middle_view = cutaway_view("mid-tunnel", middle, middle_radius, middle_tangent,
+        middle_side, middle_distance, min(total, middle_distance + 2.0))
+    ground["focus_radius"] = 20.0
+    middle_view["focus_radius"] = 20.0
+    middle_camera, _ = interpolate_route(path, max(0.0, middle_distance - 6.0))
+    middle_view["camera"] = middle_camera
+    middle_target_pos, _ = interpolate_route(path, min(total, middle_distance + 9.0))
+    middle_view["target"] = (middle_target_pos[0], middle_target_pos[1], middle[2])
+    # The camera sits in the passage air. Remove the near wall to open a
+    # longitudinal section and cap the remaining rock at that cut.
+    middle_cut_point = (middle[0] - middle_side[0] * 2.5,
+        middle[1] - middle_side[1] * 2.5, middle[2])
+    middle_view["clip"] = (*middle_side,
+        -sum(middle_side[axis] * middle_cut_point[axis] for axis in range(3)))
+    middle_view["camera_location"] = "passage-air"
+    middle_view["yaw"], middle_view["pitch"] = camera_angles(
+        middle_view["camera"], middle_view["target"])
+    return (ground, entry_view, middle_view, arrival), total, lower_index
+
+
+def export_capture(scene_name, source, recipe, passage, endpoint, view):
+    stem = f"{passage['stable_id'].replace('/', '-')}-{endpoint}"
+    view["name"] = stem
+    mesh = OUT / f"{stem}.vfmesh"
+    png = PNG_DIR / f"{stem}.png"
+    jpg = CAPTURES / f"{stem}.jpg"
+    yaw, pitch = view["yaw"], view["pitch"]
+    camera = view["camera"]
+    export_camera = view.get("focus", camera)
+    run(f"{stem}-export", [HEADLESS, source, "--workers=12",
+        "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+        "--force-generate", "--clip-radius=3", "--max-clip-level=0", "--max-level=0",
+        "--render-distance-chunks=0", f"--recipe={recipe}",
+        f"--camera={fmt((*export_camera, yaw, pitch))}", f"--mesh-export={mesh}"])
+    render_clip = view["clip"]
+    surface = None
+    if view.get("outside_camera", False):
+        surface = terrain_surface_near(mesh, *view["camera_xy"], view["target"][2])
+        if surface is None:
+            camera = (view["camera_xy"][0], view["camera_xy"][1], view["eye_height_z"])
+        else:
+            camera = (surface[0], surface[1], surface[2] + 1.6)
+    elif render_clip is not None:
+        camera = view["camera"]
+    yaw, pitch = camera_angles(camera, view["target"])
+    print(f"[L67CaptureCamera] view={stem} camera_m=({fmt(camera)}) "
+        f"target_m=({fmt(view['target'])}) "
+        f"clip={fmt(render_clip) if render_clip is not None else 'none'} fov_deg=80",
+        flush=True)
+    render = [RENDERER, mesh, png, "--size=1600x900", "--fov-deg=80",
+        f"--camera-m={fmt(camera)}", f"--yaw-deg={yaw:.6f}", f"--pitch-deg={pitch:.6f}",
+        "--tile-skirts=off", "--shade=readable", "--headlamp=on", "--height-tint=on",
+        f"--height-center-m={view['target'][2]:.6f}", "--height-range-m=8", "--tile-edges=off"]
+    if view.get("focus_radius", 24.0) is not None:
+        render.append(f"--focus-region={fmt((*view['focus'], view.get('focus_radius', 24.0)))}")
+    if render_clip is not None:
+        render.append(f"--clip-plane={fmt(render_clip)}")
+    run(f"{stem}-render", render)
+    run(f"{stem}-jpeg", ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
+        "-y", "-i", png, "-frames:v", "1", "-q:v", "4", jpg])
+    size = jpg.stat().st_size if jpg.exists() else 0
+    print(f"[L67CaptureJPEG] file={jpg.relative_to(ROOT)} bytes={size} "
+        f"status={'PASS' if 0 < size <= 300_000 else 'FAIL'}", flush=True)
+    if not 0 < size <= 300_000:
+        raise SystemExit(f"{jpg.name} is missing or exceeds 300 KB")
+
+
+for scene_name, source, recipe, mouth_generator, preferred_side in RECIPE_INPUTS:
+    if OPTIONS.scene and scene_name != OPTIONS.scene:
+        continue
+    layout = load_layout(scene_name, source, recipe)
+    passage, _ = select_passage(layout, mouth_generator, preferred_side)
+    forward_views, route_length, lower_index = make_views(layout, passage, False)
+    reverse_views, _, _ = make_views(layout, passage, True)
+    print(f"[L67CapturePassage] interface={scene_name.removeprefix('passage-')} "
+        f"id={passage['stable_id']} route_m={route_length:.3f} "
+        f"control_points={lower_index + 1}", flush=True)
+    endpoint_views = (
+        ("arrival-mouth", forward_views[0] if scene_name == "passage-0-1" else forward_views[1]),
+        ("departure-mouth", reverse_views[3]),
+    )
+    for endpoint, view in endpoint_views:
+        if OPTIONS.view and endpoint != OPTIONS.view:
+            continue
+        export_capture(scene_name, source, recipe, passage, endpoint, view)
+    if scene_name == "passage-1-2" and (OPTIONS.view is None or OPTIONS.view == "mid-tunnel"):
+        export_capture(scene_name, source, recipe, passage, "mid-tunnel", forward_views[2])

Standalone/Research/WorldAssemblerM3/Linux67/REPORT.md

@@ -0,0 +1,81 @@
+# L67 — four-strate passage walkability
+
+## Cause and fix
+
+The FI, TN, and VS paths use the compiled analytic base evaluator and then the shared strate composer. The “native” 5/5 result was the same composed field with resolved passages removed; it was not a raw-generator probe. The band stage is therefore not the difference. The passage carve and the support/capsule gates are.
+
+- **0–1 SW→FI:** at the failed probe `(21.366, -11.480, -726.367)`, passage 0 first restored support, then passage 1’s bore changed density to `+1.613` (`carve_sdf=-0.292`), removing it. The shared composer now defers that support only when a physically overlapping later bore can reach it, then applies it after the later carve. The column’s natural relief is predictor-driven and tapers at the root; relief rose from `0.172 m` to `0.219 m`.
+- **1–2 FI→TN:** at `(2.419, -13.433, -735.870)`, support restoration was rejected by an adjacent route segment’s player-capsule test (`clearance=-0.245 m`, required `0.045 m`). The segment-specific overlap candidates now keep that test local to physically relevant route geometry. The reported `0.2498 m` step came from the audit switching to a neighboring zero crossing on its `0.25 m` scan. Refining and following the same root shows a continuous floor; the step audit now reports `0.000 m`.
+- **2–3 TN→VS:** at `(-1.365, -15.673, -897.088)`, the same capsule gate rejected support next to route segment 81 (`clearance=-0.329 m`). The shared segment-overlap handling fixes this link too.
+
+The L66 `passageIndex>0` / `strates.size()>2` switches are gone. “Internal chain” now means both mouths lie inside their endpoint strata content bands and neither endpoint is a SurfaceWorld landing. Lower-mouth body overlap uses actual 3D distance to the mouth and tread, independent of plan length or passage index.
+
+## Audit
+
+All existing thresholds are unchanged. The L66 baseline binary reproduced the original failures.
+
+| Passage | L66 negative control | L67 result |
+|---|---|---|
+| 0–1 SW→FI | 59 unsupported; column relief `0.172 m < 0.20 m` | 0 unsupported / 0 blocked / 0 grade failures; wall/floor ripple `1.49 / 0.06 cm`; column relief `0.219 m`; wall relief `0.267 m` |
+| 1–2 FI→TN | 3 unsupported; wall/floor ripple `6.78 / 2.90 cm`; apparent `0.2498 m` step | 0 / 0 / 0; wall/floor ripple `2.29 / 1.23 cm`; refined step `0.000 m`; wall relief `0.257 m` |
+| 2–3 TN→VS | 2 unsupported | 0 / 0 / 0; wall/floor ripple `1.48 / 0.47 cm`; wall relief `0.248 m` |
+
+All three now pass support, blocked, grade, mouth-binding, ripple, and naturalness gates. The detailed final audit is in [`owner-four-strata-route4.log`](../../../../Saved/Linux/l67/logs/owner-four-strata-route4.log); the measured composition trace is in [`l66-root-refined-audit.log`](../../../../Saved/Linux/l67/logs/l66-root-refined-audit.log).
+
+## Controls, hashes, and builds
+
+- The L66 build remains a negative control: it reproduces `59 / 3 / 2` unsupported and the `0.172 m` column relief failure. The expected audit exit is 10.
+- The pinned fast tier passes: **269 PASS, 5 diagnostic, overall PASS**. The prior L52 surface-world hash comparison is diagnostic because the route output changed; the changed style-1 baseline is [pinned at v212](hash-baselines/owner-hash-surface-world-style1-v212.log). See the [fast summary](../../../../Saved/Linux/l67/verify/fast-summary.json).
+- Evaluator version is **212** (from 211), required because shared tread composition and route selection changed generated output. Source stamp: `d49aa8d941fb390818569243d7783f3e2799795244a8d7ca48e3e640d4a2876f`.
+- All four strata produced 12 equal hash rows at each of W1/W8/W12 ([determinism summary](../../../../Saved/Linux/l67/verify/owner-w1-w8-w12-determinism.json)). Clang and GCC builds both pass.
+- Changed implementation files are `Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h`, `Standalone/Core/src/ResolvedLayoutInternal.h`, `Standalone/Core/src/ShapeWorldInternal.h`, `Standalone/Source/OwnerWorldLoader.h`, `Standalone/Source/StreamBenchmarkPipeline.h`, and `Standalone/Tools/verify/verify.py`. No Unreal `Source/` files changed.
+
+## Cost
+
+Three interleaved whole-view pairs per strate, L66→L67 median seconds ([summary](../../../../Saved/Linux/l67/cost/cost-summary.json)):
+
+| Strate | L66 | L67 | Change |
+|---:|---:|---:|---:|
+| 0 | 1.101 | 1.121 | +1.8% |
+| 1 | 1.575 | 1.552 | −1.5% |
+| 2 | 0.581 | 0.602 | +3.6% |
+| 3 | 0.216 | 0.212 | −1.9% |
+
+Strate 2’s samples overlap (`0.582–0.600 s`) and paired results are within observed run variation. The route chooser now selects the shortest candidate within `0.10 m` of maximum sampled tread clearance, with tangent alignment as a tie-breaker. It also skips an extra closure turn when mouth separation exceeds the tread envelope; the FI→TN route is `114.231 m` rather than the earlier `165.799 m` candidate.
+
+## Captures
+
+Seven JPEGs are in `captures/`; each is under 300 KB. The TN→VS endpoint meshes are sparse in these offscreen views, so those two frames show the nearby cave/strate surface more clearly than the tread.
+
+- 0–1 arrival [26,342 B](captures/passage-0-1-0-arrival-mouth.jpg), departure [40,012 B](captures/passage-0-1-0-departure-mouth.jpg)
+- 1–2 arrival [34,298 B](captures/passage-1-2-0-arrival-mouth.jpg), departure [42,450 B](captures/passage-1-2-0-departure-mouth.jpg)
+- 2–3 arrival [23,937 B](captures/passage-2-3-0-arrival-mouth.jpg), departure [23,380 B](captures/passage-2-3-0-departure-mouth.jpg)
+- Mid-tunnel, 1–2 [22,392 B](captures/passage-1-2-0-mid-tunnel.jpg)
+
+## Failed runs
+
+- The expected L66 negative-control audit exited 10 after reproducing the failures.
+- One p0 clipped arrival-camera trial exited 3 because the clip plane left two open contours. It was replaced by the successful uncut SurfaceWorld entrance view.
+- A p2 clipped arrival-camera trial also exited 3 on open contours. The final endpoint image uses the no-clip interior view. Both cap failures are recorded in [`failed-capture-trials.log`](../../../../Saved/Linux/l67/logs/failed-capture-trials.log).
+- No final capture, Clang/GCC build, determinism run, fast-tier gate, or cost run failed. No run exceeded 30 minutes.
+
+## Audit controls (follow-up)
+
+This section supersedes the earlier wall-ripple values; the support, blocked, grade, mouth, and column results remain as reported. The residual-only gauge omitted `pose.radius` and hid an authored-radius beat:
+
+| Field / gauge | Old gauge (authored radius, linear detrend) | Residual-only gauge |
+|---|---:|---:|
+| L66 four-strata field | 6.78 cm | 2.21 cm |
+| L67 four-strata field | 14.52 cm | 2.29 cm |
+
+On the old gauge, the geometry change raised 1–2 by 7.74 cm. On L67 geometry, the residual-only gauge then removed 12.23 cm; the reported 6.78→2.29 cm drop therefore masked the radius beat. The final gauge keeps `sampleRadius + 0.5*(left+right)` and cubic-detrends each 32 m window. The 0.18 m is the probe depth inside the authored radius; its former standalone subtraction is removed. The cubic baseline leaves the 0–1 and 2–3 taper profiles below 0.01 cm, while 1–2 retains a 4.77 cm authored-radius beat at 7.06 m. Final ripple results are 1.45 / 7.27 / 0.92 cm: 1–2 fails the unchanged 3.5 cm wall limit. Support, blocked, grade, and mouth-binding checks still pass for all three; overall passage audit is 2/3. See [`audit-control-l67-final-owner.log`](../../../../Saved/Linux/l67/logs/audit-control-l67-final-owner.log) and [`audit-control-authored-radius-all.log`](../../../../Saved/Linux/l67/logs/audit-control-authored-radius-all.log).
+
+| Negative control under the updated gauge | Measured | Result |
+|---|---:|---|
+| L35 wall ribs | 9.75 cm at 6.50 m; limit 3.50 cm | Detected |
+| Synthetic wall spheres / floor beads | 5.98 / 5.98 cm; limits 3.50 / 2.50 cm | Detected |
+| Synthetic signed-distance floor step | 0.25 m step; 2.97 cm ripple vs 2.50 cm limit | Detected |
+| L36 washboard field, five-step root refinement | 6.46 cm; limit 2.50 cm | Detected |
+| L23 terrace profile | 2.00 m flat then 0.25 m step | Detected |
+
+No control passed, so no old audit behavior was restored. Logs: [L35 ribs](../../../../Saved/Linux/l67/logs/audit-control-l35-wall-ribs-cubic-audit.log), [L36 washboard](../../../../Saved/Linux/l67/logs/audit-control-l36-washboard-l35field-bisection.log). The L67 synthetic controls are in the final owner log above. One direct link of the current headless code against archived Core libraries failed route setup and was discarded; the control runs used source/Core-matched L35 builds. The follow-up changed only `Standalone/Source/StreamBenchmarkPipeline.h`; Clang Linux build succeeded. No timing run, commit, push, or stash was made.

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())

Standalone/Research/WorldAssemblerM3/Linux67/RunOwnerW12DeterminismL67.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""Compare owner four-strata W12 hashes with the pinned W1/W8 cameras."""
+import json
+import re
+import subprocess
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l67"
+DATA = ROOT / "Standalone/data/owner_world.json"
+BINARY = OUT / "bin-final/VoxelForgeCoreHeadless-l67-final-clang"
+HASH_RE = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
+CAMERA_RE = re.compile(r"camera_m=\(([-0-9.]+),([-0-9.]+),([-0-9.]+)\)")
+RESULTS = []
+
+
+def hashes(path):
+    return HASH_RE.findall(path.read_text(encoding="utf-8", errors="replace"))
+
+
+def main():
+    logs = OUT / "logs"
+    layouts = OUT / "layouts"
+    logs.mkdir(parents=True, exist_ok=True)
+    layouts.mkdir(parents=True, exist_ok=True)
+    for strate in range(4):
+        w1_path = OUT / "verify" / f"owner-new-plan-clang-strate{strate}-w1.log"
+        w8_path = OUT / "verify" / f"owner-new-plan-clang-strate{strate}-w8.log"
+        match = CAMERA_RE.search(w1_path.read_text(encoding="utf-8", errors="replace"))
+        if not match:
+            raise RuntimeError(f"camera not found in {w1_path}")
+        camera = ",".join(match.groups()) + ",0.000000,0.000000"
+        log_path = logs / f"owner-new-plan-clang-strate{strate}-w12-final.log"
+        layout_path = layouts / f"owner-new-plan-clang-strate{strate}-w12-final.json"
+        command = [
+            "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
+            "timeout", "1800s", str(BINARY), str(DATA), "--workers=12",
+            "--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=1800, check=False)
+        current = hashes(log_path)
+        w1 = hashes(w1_path)
+        w8 = hashes(w8_path)
+        passed = result.returncode == 0 and len(current) == 12 \
+            and current == w1 == w8
+        row = {"strate": strate, "exit_code": result.returncode,
+            "w1_hashes": len(w1), "w8_hashes": len(w8),
+            "w12_hashes": len(current), "w1_w8_w12_equal": passed,
+            "log": str(log_path.relative_to(ROOT))}
+        RESULTS.append(row)
+        print(json.dumps(row, sort_keys=True), flush=True)
+    summary = {"status": "PASS" if all(row["w1_w8_w12_equal"] for row in RESULTS)
+        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"[L67OwnerW1W8W12] status={summary['status']}", flush=True)
+    return 0 if summary["status"] == "PASS" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())