passages: tunnels own their floor - flat-bottomed tube + solid shell (L109, v217) - pending visual review

Owner design: flat world-horizontal floor (0.50 m corner blend), 0.75 m solid shell written only
where the host field is air (interiors union first and beat every shell), 5 m cubic mouth ramps.
Removed route support restoration, deferred support, support columns, mouth-support restoration
and their capsule checks (-5,129 / +1,641 lines). Near-ready @W12: FI 1.39 -> 0.86, TN 1.29 ->
0.90, VS 0.85 -> 0.74, SW 0.70 -> 0.76 s (more shell/skirt surface). All walk audits pass;
Clang/GCC W1/W8/W12 deterministic; fast tier PASS; Linux UE builds; 6 UE arrival traces pass.
OPEN ISSUE: open-air shell (e.g. passage 0-1, 1037-1489 m route span) shows a regular stepped
banding pattern - not merged into assembler/world until fixed/approved.

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

Standalone/Tools/verify/verify.py

@@ -122,11 +122,11 @@ RECIPE_RE = re.compile(
 
 def owner_hash_baseline(recipe: str, style: int) -> tuple[Path, str]:
     if recipe == "surface-world" and style == 1:
-        return (BASELINES / "owner-hash/canonical/owner-hash-surface-world-style1-v216.baseline",
-                "L100-v216-tunnel-owns-interior")
+        return (BASELINES / "owner-hash/canonical/owner-hash-surface-world-style1-v217.baseline",
+                "L109-v217-flat-floor-hollow-shell")
     if recipe == "floating-islands" and style == 2:
-        return (BASELINES / "owner-hash/canonical/owner-hash-floating-islands-style2-v216.baseline",
-                "L100-v216-tunnel-owns-interior")
+        return (BASELINES / "owner-hash/canonical/owner-hash-floating-islands-style2-v217.baseline",
+                "L109-v217-flat-floor-hollow-shell")
     raise VerificationFailure(f"no pinned owner hash baseline for {recipe} style {style}")
 
 
@@ -176,9 +176,7 @@ def validate_passage(runner: VerificationRunner, name: str, output: str,
         ("mouth-profile", r"^\[PassageMouthProfileAudit\].*status=PASS$"),
         ("route-binding", r"^\[ResolvedStrateRouteAudit\].*mouth_binding=PASS status=PASS$"),
         ("naturalness", r"^\[PassageNaturalnessSummary\].*status=PASS$"),
-        ("open-air", r"^\[PassageOpenAirAuditSummary\].*status=PASS$"),
-        ("no-long-bridge", r"^\[PassageNoLongBridgeAudit\].*status=PASS$"),
-        ("rock-columns", r"^\[PassageRockColumnAuditSummary\].*status=PASS$"),
+        ("tunnel-shell", r"^\[PassageShellAuditSummary\].*status=PASS$"),
         ("ripple-controls", r"^\[PassageRippleAuditSummary\].*status=PASS$"),
         ("passage-summary", r"^\[ResolvedPassageAuditSummary\].*route_binding_failures=0 .*status=PASS$"),
     )
@@ -203,14 +201,26 @@ def validate_passage(runner: VerificationRunner, name: str, output: str,
         floor_threshold = re.search(r"floor_threshold_m=([-0-9.]+)", line)
         wall_coverage = parse_ratio(line, "coverage")
         floor_coverage = parse_ratio(line, "floor_coverage")
+        floor_coverage_pair = re.search(r"floor_coverage=(\d+)/(\d+)", line)
+        floor_overlap_skips = re.search(r"floor_overlap_skips=(\d+)", line)
+        floor_mode = re.search(r"floor_mode=([^ ]+)", line)
+        floor_overlap_only = bool(
+            floor_mode and floor_mode.group(1) == "overlap_only"
+            and floor_coverage_pair and floor_coverage_pair.groups() == ("0", "0")
+            and floor_overlap_skips and int(floor_overlap_skips.group(1)) > 0)
+        floor_measured = bool(
+            floor_mode and floor_mode.group(1) in ("measured", "measured_with_overlap")
+            and floor_coverage is not None and floor_coverage >= 0.75)
         ripple_ok &= bool(
             "status=PASS" in line and wall and wall_threshold and floor and floor_threshold
             and wall_coverage is not None and floor_coverage is not None
             and float(wall.group(1)) <= float(wall_threshold.group(1))
             and float(floor.group(1)) <= float(floor_threshold.group(1))
-            and wall_coverage >= 0.75 and floor_coverage >= 0.75)
+            and wall_coverage >= 0.75 and (floor_measured or floor_overlap_only))
     passed_all &= ripple_ok
-    detail = f"profiles={len(rows)} wall/floor amplitudes under their thresholds; coverage>=0.75"
+    detail = (f"profiles={len(rows)} wall/floor amplitudes under their thresholds; "
+              "wall coverage>=0.75 and floor measured coverage>=0.75 or all probes "
+              "explicitly masked by overlapping tunnel interior air")
     if defer:
         defer_requirement(runner, f"{name}:wall-floor-ripple-and-coverage", ripple_ok, detail)
     else:
@@ -256,11 +266,34 @@ def run_owner_passages(runner: VerificationRunner, binaries: tuple[Path, ...]) -
             if compiler == "clang":
                 measured = measure_owner_step(output)
                 worst = measured.get("worst")
+                ripple_rows = re.findall(r"^\[PassageRippleAudit\].*$", output, re.M)
+                overlap_only = bool(ripple_rows) and all(
+                    (mode := re.search(r"floor_mode=([^ ]+)", line)) is not None
+                    and mode.group(1) == "overlap_only"
+                    and (coverage := re.search(r"floor_coverage=(\d+)/(\d+)", line)) is not None
+                    and coverage.groups() == ("0", "0")
+                    and (skips := re.search(r"floor_overlap_skips=(\d+)", line)) is not None
+                    and int(skips.group(1)) > 0
+                    for line in ripple_rows)
+                walkability_rows = re.findall(r"^\[ResolvedPassageAudit\].*$", output, re.M)
+                walkability_clear = bool(walkability_rows) and all(
+                    "walkability=PASS" in line
+                    and (blocked := re.search(r"blocked=(\d+)", line)) is not None
+                    and blocked.group(1) == "0"
+                    and (unsupported := re.search(r"unsupported=(\d+)", line)) is not None
+                    and unsupported.group(1) == "0"
+                    and (grade := re.search(r"grade_failures=(\d+)", line)) is not None
+                    and grade.group(1) == "0"
+                    for line in walkability_rows)
+                masked_by_overlap = (measured["adjacent_pairs"] == 0
+                    and overlap_only and walkability_clear)
+                step_passed = bool(measured["passed"] or masked_by_overlap)
                 runner.require(f"{name}:adjacent-owner-step",
-                    bool(measured["passed"]),
+                    step_passed,
                     f"max_step_m={measured['maximum_adjacent_step_m']:.6f} "
                     f"limit_m=0.100 pairs={measured['adjacent_pairs']} "
                     f"fitted_periods_m={measured['fitted_periods_m']} "
+                    f"overlap_only_mask={str(masked_by_overlap).lower()} "
                     f"period_role=diagnostic worst={worst}")
     return result
 
@@ -663,7 +696,7 @@ def run_hash_pairs(runner: VerificationRunner,
             diagnostic = {"name": "owner-hash-surface-world-matches-L52-diagnostic",
                 "status": "DIAGNOSTIC",
                 "detail": f"matches={hashes[12] == l52_hashes} L52 rows={len(l52_hashes)}; "
-                    "the v216 passage interior ownership change has its own pinned baseline"}
+                    "the v217 flat-floor hollow-shell geometry has its own pinned baseline"}
             runner.steps.append(diagnostic)
             print(f"[{runner.tier}] {diagnostic['name']} {diagnostic['detail']}", flush=True)
         baseline = BASELINES / "owner-hash/l46" / f"owner-hash-{recipe}-style{style}-w12.baseline"