wip: opt-in landing-pad contract + Core.Liminal.Field v2 pads (L145)

Layers may publish certified arrival/departure pads; the passage planner binds endpoints and tangents to them;
no-pad layouts serialize unchanged (owner canonical hashes match v227). Pads removed the endpoint grade failures;
seeds 0-4 passed at a 45 m margin, but seed 5 still has 289 blocked passage-capsule samples ~29 m before the
departure pad, where the composed field stays solid (-0.162) inside the tube over native ground (-3.6). Ripple
audit now keeps true route distance across masked gaps (with a synthetic control).

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

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -1842,6 +1842,9 @@ int main(int argc,char** argv)
     }
     VoxelForgeCore::ResolvedLayoutSnapshotV3 resolvedLayout;
     {
+        const VFJson::Value& coreLiminalConfig=ownerJsonRoot.Get("core_liminal_field");
+        const bool hasCoreLiminalField=!std::holds_alternative<std::nullptr_t>(
+            coreLiminalConfig.Data);
         const std::string variant=options.LatticeRecipe
             ?"lattice/"+std::to_string(options.LatticeStrateIndex)
             :options.CavesRecipe?"caves"
@@ -1852,16 +1855,14 @@ int main(int argc,char** argv)
             ?StandaloneWorldAssemblyPrototype::ImportExportedResolvedLayout(
                 ownerJsonRoot,resolvedLayout,error)
             :StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
-                *ownerWorld,worldAssembly,variant,resolvedLayout,error);
+                *ownerWorld,worldAssembly,variant,resolvedLayout,error,
+                !hasCoreLiminalField);
         if(!layoutResolved)
         {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
         if(useExportedCorePlan&&!options.NativeOwnerFloatingIslandsRecipe
             &&!StandaloneWorldAssemblyPrototype::ValidateExportedCorePlanMatchesOwner(
                 *ownerWorld,worldAssembly,resolvedLayout,error))
         {std::fprintf(stderr,"Unreal-resolved Core plan/owner slot validation failed: %s\n",error.c_str());return 2;}
-        const VFJson::Value& coreLiminalConfig=ownerJsonRoot.Get("core_liminal_field");
-        const bool hasCoreLiminalField=!std::holds_alternative<std::nullptr_t>(
-            coreLiminalConfig.Data);
         if(hasCoreLiminalField)
         {
             const VFJson::Value& versionValue=coreLiminalConfig.Get("version");
@@ -1871,7 +1872,7 @@ int main(int argc,char** argv)
             const auto* policy=std::get_if<std::string>(&coreLiminalConfig.Get("variant_policy").Data);
             if(!coreLiminalConfig.IsObject()
                 ||!versionValue.IsNumber()
-                ||versionValue.Number()!=VoxelForgeCore::CoreLiminalFieldRecipeVersionV1
+                ||versionValue.Number()!=VoxelForgeCore::CoreLiminalFieldRecipeVersionV2
                 ||!strateValue.IsNumber()
                 ||std::trunc(strateValue.Number())!=strateValue.Number()
                 ||strateValue.Number()<0.0
@@ -1896,7 +1897,34 @@ int main(int argc,char** argv)
             liminalPlan.strateIndex=static_cast<std::int32_t>(strateIndex);
             liminalPlan.topChunkZ=slot->TopChunkZ;
             liminalPlan.bottomChunkZ=slot->BottomChunkZ;
-            if(!VoxelForgeCore::PlanCoreLiminalFieldV1(worldAssembly.recipe,
+            resolvedLayout.passages.clear();
+            if(!VoxelForgeCore::PrepareCoreLiminalLandingPadsV2(worldAssembly.recipe,
+                    liminalPlan,resolvedLayout,error))
+            {std::fprintf(stderr,"Core.Liminal.Field landing-pad preparation failed: %s\n",error.c_str());return 2;}
+            const auto passageConfigs=
+                StandaloneWorldAssemblyPrototype::BuildResolvedLayoutPassageConfigs(*ownerWorld);
+            auto uncertifiedControl=resolvedLayout;
+            const auto controlStratum=std::find_if(uncertifiedControl.strates.begin(),
+                uncertifiedControl.strates.end(),[&](const auto& value)
+                    {return value.strateIndex==strateIndex;});
+            bool landingPadNegativeControlRejected=false;
+            if(controlStratum!=uncertifiedControl.strates.end()
+                &&!controlStratum->landingPads.empty())
+            {
+                controlStratum->landingPads.front().certifiedWalkableWithSupport=false;
+                std::string controlError;
+                landingPadNegativeControlRejected=
+                    !VoxelForgeCore::PlanResolvedLayoutPassagesV1(uncertifiedControl,
+                        ownerWorld->Seed,passageConfigs,controlError);
+            }
+            std::printf("[LandingPadNegativeControl] uncertified_rejected=%s status=%s\n",
+                landingPadNegativeControlRejected?"true":"false",
+                landingPadNegativeControlRejected?"PASS":"FAIL");
+            if(!landingPadNegativeControlRejected)return 2;
+            if(!VoxelForgeCore::PlanResolvedLayoutPassagesV1(resolvedLayout,
+                    ownerWorld->Seed,passageConfigs,error))
+            {std::fprintf(stderr,"Core.Liminal.Field pad-bound passage planning failed: %s\n",error.c_str());return 2;}
+            if(!VoxelForgeCore::PlanCoreLiminalFieldV2(worldAssembly.recipe,
                     liminalPlan,resolvedLayout,error))
             {std::fprintf(stderr,"Core.Liminal.Field planning failed: %s\n",error.c_str());return 2;}
             worldAssembly.plan.strates.push_back(std::move(liminalPlan));
@@ -1910,17 +1938,19 @@ int main(int argc,char** argv)
             {std::fprintf(stderr,"Core.Liminal.Field manifest failed canonical JSON round-trip: %s\n",error.c_str());return 2;}
             const auto plan=std::find_if(worldAssembly.plan.strates.begin(),
                 worldAssembly.plan.strates.end(),[&](const auto& value)
-                    {return value.strateIndex==strateIndex&&value.liminalField.version!=0;});
+                    {return value.strateIndex==strateIndex
+                        &&value.liminalField.version==VoxelForgeCore::CoreLiminalFieldRecipeVersionV2;});
             if(plan==worldAssembly.plan.strates.end())
             {std::fprintf(stderr,"Core.Liminal.Field finalized plan is missing\n");return 2;}
             auto& resolvedLiminal=*std::find_if(resolvedLayout.strates.begin(),
                 resolvedLayout.strates.end(),[&](const auto& value)
                     {return value.strateIndex==strateIndex;});
             resolvedLiminal.recipeId=std::string(VoxelForgeCore::CoreLiminalFieldRecipeIdV1);
-            resolvedLiminal.recipeVersion=VoxelForgeCore::CoreLiminalFieldRecipeVersionV1;
+            resolvedLiminal.recipeVersion=VoxelForgeCore::CoreLiminalFieldRecipeVersionV2;
             resolvedLiminal.anchors.erase(std::remove_if(resolvedLiminal.anchors.begin(),
                 resolvedLiminal.anchors.end(),[](const auto& anchor)
-                    {return anchor.kind=="heightfield_profile";}),resolvedLiminal.anchors.end());
+                    {return anchor.kind=="heightfield_profile"||anchor.kind=="route_point";}),
+                resolvedLiminal.anchors.end());
             VoxelForgeCore::ResolvedLayoutAnchorV2 profileAnchor;
             profileAnchor.kind="heightfield_profile";
             profileAnchor.stableId="heightfield-profile/liminal/"