wip: Core.Liminal.Field v1 recipe, 4 seed-selected variants between fixed mouths (L144, fails mouth joins)

Plans and draws flat field+monolith, repeating hills, road over cloud floor and pillar grid in a 3-strata fixture,
binding passage/0-1 and 1-2 as fixed endpoints. Composed W1 probes: 3/4 seeds fail one passage interface, 4/4 fail the
liminal walk audit near the mouths (support itself passes). Stopped per AGENTS.md. Same mouth-ownership failure
class as FI (L133/L140) and VS seed 2 (L139).

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

Standalone/Core/src/ResolvedLayoutInternal.h

@@ -249,6 +249,71 @@ namespace
                         /WorldAssemblySubvoxelsPerVoxel));
             return result;
         };
+        const bool liminalRouteStamp=strate->recipeId==CoreLiminalFieldRecipeIdV1
+            &&stamp.stableId.starts_with("core/liminal-field/route/")
+            &&(stamp.kind==ResolvedSdfStampKindV1::fillSweptDeckSegment
+                ||stamp.kind==ResolvedSdfStampKindV1::fillPillar);
+        if(liminalRouteStamp)
+        {
+            const auto variant=std::find_if(strate->anchors.begin(),strate->anchors.end(),
+                [](const auto& anchor){return anchor.kind=="liminal_variant"
+                    &&anchor.values.size()>=6;});
+            std::vector<const ResolvedLayoutAnchorV2*> points;
+            for(const auto& anchor:strate->anchors)
+                if(anchor.kind=="liminal_route_point"&&anchor.values.size()>=4)
+                    points.push_back(&anchor);
+            if(variant==strate->anchors.end()||points.size()<2)
+            {if(reason)*reason="Core.Liminal.Field route stamp has no versioned fixed-mouth route";return false;}
+            const auto routePoint=[&](const ResolvedLayoutAnchorV2& anchor)
+            {
+                std::array<std::int64_t,3> q={anchor.values[0],anchor.values[1],anchor.values[2]};
+                return qToMicrometres(q);
+            };
+            const std::int64_t halfThickness=static_cast<std::int64_t>(std::llround(
+                static_cast<double>(variant->values[5])*coreMicrometres
+                    /WorldAssemblySubvoxelsPerVoxel));
+            if(stamp.kind==ResolvedSdfStampKindV1::fillSweptDeckSegment)
+            {
+                const auto first=routePoint(*points.front());
+                const auto last=routePoint(*points.back());
+                if(stamp.sweepPathMicrometres.size()<2
+                    ||stamp.sweepPathMicrometres.front()[0]!=first[0]
+                    ||stamp.sweepPathMicrometres.front()[1]!=first[1]
+                    ||stamp.sweepPathMicrometres.front()[2]!=first[2]-halfThickness
+                    ||stamp.sweepPathMicrometres.back()[0]!=last[0]
+                    ||stamp.sweepPathMicrometres.back()[1]!=last[1]
+                    ||stamp.sweepPathMicrometres.back()[2]!=last[2]-halfThickness)
+                {if(reason)*reason="Core.Liminal.Field deck does not terminate at its fixed passage mouths";return false;}
+                return true;
+            }
+            const auto deck=std::find_if(layout.stamps.begin(),layout.stamps.end(),
+                [&](const auto& existing){return existing.strateIndex==stamp.strateIndex
+                    &&existing.stableId=="core/liminal-field/route/deck/000"
+                    &&existing.kind==ResolvedSdfStampKindV1::fillSweptDeckSegment;});
+            if(deck==layout.stamps.end()||deck->sweepPathMicrometres.size()<2)
+            {if(reason)*reason="Core.Liminal.Field support has no previously resolved route deck";return false;}
+            double distance=std::numeric_limits<double>::infinity();
+            for(std::size_t i=1;i<deck->sweepPathMicrometres.size();++i)
+            {
+                const auto& a=deck->sweepPathMicrometres[i-1];
+                const auto& b=deck->sweepPathMicrometres[i];
+                const double dx=static_cast<double>(b[0]-a[0]);
+                const double dy=static_cast<double>(b[1]-a[1]);
+                const double lengthSquared=dx*dx+dy*dy;
+                const double t=lengthSquared>0.0?std::clamp(
+                    ((stamp.positionMicrometres[0]-a[0])*dx
+                        +(stamp.positionMicrometres[1]-a[1])*dy)/lengthSquared,
+                    0.0,1.0):0.0;
+                const double offsetX=stamp.positionMicrometres[0]-(a[0]+t*dx);
+                const double offsetY=stamp.positionMicrometres[1]-(a[1]+t*dy);
+                distance=std::min(distance,std::hypot(offsetX,offsetY));
+            }
+            const double corridorRadius=deck->halfExtentsMicrometres[1]
+                +stamp.halfExtentsMicrometres[0]+RouteClearanceMicrometres;
+            if(distance>corridorRadius)
+            {if(reason)*reason="Core.Liminal.Field route stamp is outside its versioned route corridor";return false;}
+            return true;
+        }
         for(const auto& passage:layout.passages)
         {
             if(passage.upperStrateIndex!=stamp.strateIndex
@@ -1158,8 +1223,9 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
         &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV2
         &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV3
         &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV4
-        &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV5)
-        add("stamp_vocabulary_version","resolved stamps require supported vocabulary version 1 through 5");
+        &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV5
+        &&stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV6)
+        add("stamp_vocabulary_version","resolved stamps require supported vocabulary version 1 through 6");
     std::vector<std::string> stampIds;
     for(const auto& stamp:stamps)
     {
@@ -1217,11 +1283,15 @@ bool ResolvedLayoutSnapshotV3::validate(ResolvedLayoutValidationModeV3 mode,
                         validPath=validPath&&coordinate>=-1000000000000ll
                             &&coordinate<=1000000000000ll;
                     if(pointIndex>0)
-                        validPath=validPath
-                            &&stamp.sweepPathMicrometres[pointIndex-1][0]<point[0];
+                    {
+                        const auto& previous=stamp.sweepPathMicrometres[pointIndex-1];
+                        validPath=validPath&&previous!=point
+                            &&(stampVocabularyVersion>=ResolvedLayoutStampVocabularyVersionV6
+                                ||previous[0]<point[0]);
+                    }
                 }
                 if(!validPath)add("stamp_sweep_path",stamp.stableId
-                    +" has an invalid V5 path or non-increasing longitudinal axis");
+                    +" has an invalid swept-deck path for its vocabulary version");
             }
         }
         if(motif)
@@ -1749,10 +1819,20 @@ bool ResolveResolvedLayoutStampsV1(ResolvedLayoutSnapshotV3& layout,std::int32_t
     const bool hasContinuousSweptDeck=std::any_of(ordered.begin(),ordered.end(),[](const auto& request)
         {return request.kind==ResolvedSdfStampKindV1::fillSweptDeckSegment
             &&!request.sweepPathMicrometres.empty();});
+    const bool hasNonMonotoneSweptDeck=std::any_of(ordered.begin(),ordered.end(),[](const auto& request)
+    {
+        if(request.kind!=ResolvedSdfStampKindV1::fillSweptDeckSegment
+            ||request.sweepPathMicrometres.empty())return false;
+        for(std::size_t i=1;i<request.sweepPathMicrometres.size();++i)
+            if(request.sweepPathMicrometres[i-1][0]>=request.sweepPathMicrometres[i][0])
+                return true;
+        return false;
+    });
     const bool hasSweptDeck=std::any_of(ordered.begin(),ordered.end(),[](const auto& request)
         {return request.kind==ResolvedSdfStampKindV1::fillSweptDeckSegment;});
     candidate.stampVocabularyVersion=hasContinuousSweptDeck
-        ?ResolvedLayoutStampVocabularyVersionV5
+        ?(hasNonMonotoneSweptDeck?ResolvedLayoutStampVocabularyVersionV6
+            :ResolvedLayoutStampVocabularyVersionV5)
         :hasSweptDeck?ResolvedLayoutStampVocabularyVersionV4
         :ResolvedLayoutStampVocabularyVersionV1;
     candidate.stamps.clear();candidate.stamps.reserve(ordered.size());
@@ -1818,8 +1898,8 @@ bool ResolveResolvedLayoutStampsV1(ResolvedLayoutSnapshotV3& layout,std::int32_t
                 for(const auto coordinate:point)
                     if(coordinate<-1000000000000ll||coordinate>1000000000000ll)
                     {error="stamp request "+request.stableId+" has an unbounded path point";return false;}
-                if(pointIndex>0&&request.sweepPathMicrometres[pointIndex-1][0]>=point[0])
-                {error="stamp request "+request.stableId+" path X coordinates must increase strictly";return false;}
+                if(pointIndex>0&&request.sweepPathMicrometres[pointIndex-1]==point)
+                {error="stamp request "+request.stableId+" path contains a zero-length segment";return false;}
             }
         }
 
@@ -1836,6 +1916,7 @@ bool ResolveResolvedLayoutStampsV1(ResolvedLayoutSnapshotV3& layout,std::int32_t
             return static_cast<std::int64_t>(bits%span)-radius;
         };
         bool placed=false;
+        std::string lastPlacementFailure;
         for(std::uint32_t attempt=0;attempt<(request.placementRadiusMicrometres==0?1u:512u);++attempt)
         {
             ResolvedLayoutStampV1 stamp;stamp.stableId=request.stableId;
@@ -1919,11 +2000,14 @@ bool ResolveResolvedLayoutStampsV1(ResolvedLayoutSnapshotV3& layout,std::int32_t
                     stamp.boundsMaximumMicrometres[axis]=stamp.positionMicrometres[axis]+extents[axis];
                 }
             }
-            if(!LayoutStampSafe(candidate,stamp))continue;
+            std::string safetyReason;
+            if(!LayoutStampSafe(candidate,stamp,&safetyReason))
+            {lastPlacementFailure=std::move(safetyReason);continue;}
             candidate.stamps.push_back(std::move(stamp));placed=true;break;
         }
         if(!placed)
-        {error="stamp request "+request.stableId+" has no deterministic passage-safe content placement";return false;}
+        {error="stamp request "+request.stableId+" has no deterministic passage-safe content placement"
+            +(lastPlacementFailure.empty()?std::string{}:": "+lastPlacementFailure);return false;}
     }
     if(!candidate.finalize(error))return false;
     std::vector<ResolvedLayoutIssueV2> issues;std::string strictError;