feat(core): reachable SW landmark chamber demo with a reachability audit (L45); research R12

Stamp vocabulary v2; the flagged SW demo opens through a side-facing portal and a bent ramp (max 14 deg,
two landings) into a 17 x 15 m chamber with a rock dais. New reachability audit: a capsule surface search
from walkable ground near the arrival mouth to the chamber floor (66 samples, 0 blocked/unsupported); the
buried L43 layout fails it. Demo off: owner hashes identical to L44. fast/medium/full PASS (Clang+GCC).
Research R12 (read-only): composite cavern-graph generator design and slices.

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

Standalone/Tools/verify/verify.py

@@ -152,7 +152,9 @@ def run_owner_passages(runner: VerificationRunner, binaries: tuple[Path, ...]) -
         compiler = compiler_name(binary)
         for recipe, style in (("floating-islands", 2), ("surface-world", 1)):
             name = f"owner-{recipe}-style{style}-{compiler}"
+            flags = ["--landmark-chamber-demo"] if recipe == "surface-world" else []
             row, output = run_passage(runner, binary, name, OWNER, recipe, style,
+                flags=flags,
                 passage_style=2, expected_strate_styles=expected_strate_styles)
             result[f"{compiler}:{recipe}"] = (row, output)
             actual_styles = row.get("resolved_strate_styles", {})
@@ -171,6 +173,62 @@ def run_owner_passages(runner: VerificationRunner, binaries: tuple[Path, ...]) -
     return result
 
 
+def run_landmark_reachability(runner: VerificationRunner,
+                              binaries: tuple[Path, ...]) -> None:
+    for binary in binaries:
+        compiler = compiler_name(binary)
+        name = f"landmark-reachability-{compiler}"
+        row, output = runner.run_cpp(name, binary, OWNER, "surface-world",
+            ["--landmark-chamber-demo", "--audit-landmark-reachability",
+             "--max-clip-level=0", "--render-distance-chunks=0"],
+            expected_style=2, expected_strate_styles={"0": 2, "1": 1},
+            max_level=0, layout_path=OUT / "layouts" / f"{name}.json")
+        row["requested_style"] = 1
+        row["expected_passage_style"] = 2
+        passage_name = f"landmark-demo-passages-{compiler}"
+        _, passage_output = runner.run_cpp(passage_name, binary, OWNER, "surface-world",
+            ["--landmark-chamber-demo", "--audit-resolved-layout-passages",
+             "--max-clip-level=0", "--render-distance-chunks=0"],
+            expected_style=2, expected_strate_styles={"0": 2, "1": 1},
+            max_level=0, layout_path=OUT / "layouts" / f"{passage_name}.json")
+        runner.require(f"{passage_name}:demo-enabled",
+            all_match(passage_output, r"^\[LandmarkStampDemo\] enabled=true .*status=PASS$"),
+            "landmark demo flag resolved while running passage audits")
+        validate_passage(runner, passage_name, passage_output)
+
+        interface_name = f"landmark-demo-interfaces-{compiler}"
+        _, interface_output = runner.run_cpp(interface_name, binary, OWNER, "surface-world",
+            ["--landmark-chamber-demo", "--audit-strate-transitions",
+             "--max-clip-level=0", "--render-distance-chunks=0"],
+            expected_style=2, expected_strate_styles={"0": 2, "1": 1},
+            max_level=0, layout_path=OUT / "layouts" / f"{interface_name}.json")
+        runner.require(f"{interface_name}:demo-enabled",
+            all_match(interface_output, r"^\[LandmarkStampDemo\] enabled=true .*status=PASS$"),
+            "landmark demo flag resolved while running interface audits")
+        runner.require(f"{interface_name}:hole-audit",
+            all_match(interface_output, r"^\[StrateTransitionAuditSummary\].*hole_columns=0 "
+                r"air_samples=0 .*status=PASS$"),
+            "demo-on stratum interfaces contain no holes or air columns")
+        runner.require(f"{interface_name}:negative-controls",
+            all_match(interface_output, r"^\[StrateTransitionNegativeControls\].*status=PASS$"),
+            "demo-on interface audit detects both thickness controls")
+        runner.require(f"{name}:candidate-walkability",
+            all_match(output, r"^\[LandmarkWalkability\] layout=L45 .*status=PASS$"),
+            "demo capsule clearance, support and <=15 degree grade")
+        runner.require(f"{name}:buried-l43-control",
+            all_match(output, r"^\[LandmarkReachabilityControl\] layout=L43-buried .*"
+                r"result=FAIL expected=FAIL status=PASS$"),
+            "the exact buried L43 chamber fails the same route audit")
+        runner.require(f"{name}:surface-to-floor-route",
+            all_match(output, r"^\[LandmarkSurfaceRoute\] reachable=true .*"
+                r"surface_points=[1-9][0-9]* grade_limit_deg=15\.000$"),
+            "walkable surface path from ground near the arrival mouth joins the ramp")
+        runner.require(f"{name}:reachability-control-summary",
+            all_match(output, r"^\[LandmarkReachabilityAudit\] positive=PASS "
+                r"control=EXPECTED_FAIL status=PASS$"),
+            "candidate passes and buried control fails")
+
+
 def expected_control_row(runner: VerificationRunner, name: str) -> None:
     if runner.runs:
         row = runner.runs[-1]
@@ -361,6 +419,8 @@ def run_random_camera_sweep(runner: VerificationRunner, binaries: tuple[Path, ..
                             f"--clip-radius={clip_radius}",
                             f"--max-clip-level={max_clip_level}",
                             f"--max-level={max_level}", "--render-distance-chunks=0"]
+                        if recipe == "surface-world":
+                            flags.append("--landmark-chamber-demo")
                         row, output = runner.run_cpp(name, binary, OWNER, recipe, flags,
                             expected_style=2,
                             expected_strate_styles={"0": 2, "1": 1},
@@ -460,8 +520,11 @@ def run_transitions_and_invariants(runner: VerificationRunner,
         for recipe, style in (("floating-islands", 2), ("surface-world", 1)):
             for mode in ("hard", "gradient", "interleaved"):
                 name = f"transition-{recipe}-{mode}-{compiler}"
+                flags = [f"--transition-mode={mode}", "--audit-strate-transitions"]
+                if recipe == "surface-world":
+                    flags.append("--landmark-chamber-demo")
                 row, output = runner.run_cpp(name, binary, OWNER, recipe,
-                    [f"--transition-mode={mode}", "--audit-strate-transitions"],
+                    flags,
                     expected_style=2, expected_strate_styles={"0": 2, "1": 1},
                     layout_path=OUT / "layouts" / f"{name}.json")
                 row["requested_style"] = style
@@ -472,8 +535,11 @@ def run_transitions_and_invariants(runner: VerificationRunner,
                     runner.require(f"{name}:gate-{index + 1}", all_match(output, pattern), pattern)
 
             name = f"invariant-route-proof-{recipe}-{compiler}"
+            flags = ["--audit-uniform-block-proofs", "--audit-route-parity"]
+            if recipe == "surface-world":
+                flags.append("--landmark-chamber-demo")
             row, output = runner.run_cpp(name, binary, OWNER, recipe,
-                ["--audit-uniform-block-proofs", "--audit-route-parity"],
+                flags,
                 expected_style=2, expected_strate_styles={"0": 2, "1": 1},
                 layout_path=OUT / "layouts" / f"{name}.json")
             row["requested_style"] = style
@@ -545,6 +611,18 @@ def run_captures_and_mesh_audits(runner: VerificationRunner) -> None:
         script_inputs=[overview_script, VERIFY_DIR / "capture_quality.py",
                        OUT / "owner-fi-ground-mouth.vfmesh"])
 
+    landmark_script = ROOT / "Standalone/Research/WorldAssemblerM3/Linux45/CaptureLandmarkL45.py"
+    landmark_layout = OUT / "layouts" / "landmark-reachability-clang.json"
+    runner.run_stage("capture-landmark-l45", landmark_script,
+        ["--layout", str(landmark_layout), "--artifact-dir", str(OUT),
+         "--capture-dir", str(ROOT / "Standalone/Research/WorldAssemblerM3/Linux45/captures"),
+         "--data", str(OWNER)],
+        binary=CLANG, data=OWNER, recipe="surface-world", style=1,
+        layout_path=landmark_layout, env=env_for(capture=True),
+        script_inputs=[landmark_script, VERIFY_DIR / "capture_quality.py",
+            LINUX37 / "AuditMouthShapeL37.py",
+            ROOT / "Standalone/Research/WorldAssemblerM3/Linux32/AuditRingTerraceL32.py"])
+
 
 def verify_determinism_cell(runner: VerificationRunner, binary: Path,
                             kind: str, recipe: str, style: int, workers: int,
@@ -718,6 +796,7 @@ def run_cost_pairs(runner: VerificationRunner) -> None:
 def run_medium_suite(runner: VerificationRunner, *, both_compilers: bool = False) -> None:
     binaries = (CLANG, GCC) if both_compilers else (CLANG,)
     run_owner_passages(runner, binaries)
+    run_landmark_reachability(runner, binaries)
     run_regression_controls(runner)
     style_override_matrix(runner, CLANG)
     if both_compilers:
@@ -732,6 +811,7 @@ def run_medium_suite(runner: VerificationRunner, *, both_compilers: bool = False
 def run_gcc_supplement(runner: VerificationRunner) -> None:
     """Add GCC evidence to a stamped, already-passed Clang medium tier."""
     run_owner_passages(runner, (GCC,))
+    run_landmark_reachability(runner, (GCC,))
     style_override_matrix(runner, GCC)
     run_transitions_and_invariants(runner, (GCC,))
 
@@ -756,6 +836,7 @@ def main() -> int:
                 runner.probe_binary(binary)
         if ARGS.tier == "fast":
             owners = run_owner_passages(runner, (CLANG,))
+            run_landmark_reachability(runner, (CLANG,))
             run_regression_controls(runner)
             run_hash_pairs(runner, owners)
             run_random_camera_sweep(runner, (CLANG,), 3, ((3, 0, 0),))