feat(core): slab + sparse motifs, slice 1 -- flat field, monolith, platform at 0.52 s (L56); research R25

Motif vocabulary v3: version-1 records keyed by (seed, strate, stable ID) with route keepouts, band
clearance and pairwise spacing. A rounded capped-cylinder monolith (r 1.4 m, 24 m tall) and a rounded-box
plinth, smooth-unioned into a flatField floor with a 0.55 m geometric rounding (measured fillets 0.73-1.17 m).
Exact radial/box interval bounds, a BVH, isTileShapeFree aware (0 brute-force misses, false-proof controls
rejected). Final-field route passes; whole-surface audit covers foot, cap and platform edges. Cold whole
view 0.524 s. Owner world unchanged. fast/medium/full PASS (Clang and GCC).
Research R25 (self-checked): FloatingIslands LOD0 column cache conflicts.

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -1403,6 +1403,115 @@ namespace StandaloneStreamBenchmark
         return reachable&&intervalOk&&measured>=0.5;
     }
 
+    inline bool AuditMotifIntervals(const VoxelForgeCore::World& shape,
+        const VoxelForgeCore::ResolvedLayoutSnapshotV3& layout,
+        std::uint32_t voxelMicrometres)
+    {
+        using namespace VoxelForgeCore;
+        const double vm=std::max<std::uint32_t>(1,voxelMicrometres)/1.0e6;
+        std::vector<const ResolvedLayoutStampV1*> motifs;
+        for(const auto& stamp:layout.stamps)
+            if(stamp.kind==ResolvedSdfStampKindV1::fillMonolith
+                ||stamp.kind==ResolvedSdfStampKindV1::fillPlatform)
+                motifs.push_back(&stamp);
+        std::sort(motifs.begin(),motifs.end(),[](const auto* a,const auto* b)
+            {return a->stableId<b->stableId;});
+        if(layout.stampVocabularyVersion!=ResolvedLayoutStampVocabularyVersionV3
+            ||motifs.size()!=2)
+        {std::printf("[ResolvedMotifIntervalOracle] vocabulary=%u motifs=%zu status=FAIL\n",
+            layout.stampVocabularyVersion,motifs.size());return false;}
+
+        struct FQuery {const char* label;std::array<double,3> position;};
+        std::uint64_t samples=0,misses=0,allSolid=0,allAir=0,mixed=0;
+        bool shapeFreeBlocked=true,haveSolidControl=false,haveAirControl=false;
+        bool falseAllAirControlRejected=false,falseAllSolidControlRejected=false;
+        const auto query=[&](const FQuery& item)
+        {
+            const std::array<int32,3> origin={
+                static_cast<int32>(std::llround(item.position[0]/vm)),
+                static_cast<int32>(std::llround(item.position[1]/vm)),
+                static_cast<int32>(std::llround(item.position[2]/vm))};
+            const TileClass verdict=shape.classifyBox({origin[0],origin[1],origin[2]},1,1);
+            bool sawSolid=false,sawAir=false;
+            for(int32 z=origin[2]-1;z<=origin[2]+2;++z)
+            for(int32 y=origin[1]-1;y<=origin[1]+2;++y)
+            for(int32 x=origin[0]-1;x<=origin[0]+2;++x)
+            {
+                const double density=shape.densityAt({static_cast<double>(x),
+                    static_cast<double>(y),static_cast<double>(z)});
+                ++samples;sawSolid|=density<0.0;sawAir|=density>=0.0;
+                if((verdict==TileClass::allAir&&density<0.0)
+                    ||(verdict==TileClass::allSolid&&density>=0.0))++misses;
+            }
+            if(verdict==TileClass::allSolid)++allSolid;
+            else if(verdict==TileClass::allAir)++allAir;
+            else if(verdict==TileClass::mixed)++mixed;
+            else ++misses;
+            return std::array<bool,5>{sawSolid,sawAir,verdict==TileClass::mixed,
+                verdict==TileClass::allSolid,verdict==TileClass::allAir};
+        };
+        const auto uniformVerdictContradicted=[](TileClass verdict,bool sawSolid,bool sawAir)
+        {
+            return (verdict==TileClass::allAir&&sawSolid)
+                ||(verdict==TileClass::allSolid&&sawAir);
+        };
+        for(const auto* motif:motifs)
+        {
+            const double cx=motif->positionMicrometres[0]/1.0e6;
+            const double cy=motif->positionMicrometres[1]/1.0e6;
+            const double floor=motif->floorMicrometres/1.0e6;
+            const double halfX=motif->halfExtentsMicrometres[0]/1.0e6;
+            const double halfZ=motif->halfExtentsMicrometres[2]/1.0e6;
+            const double radius=motif->halfExtentsMicrometres[0]/1.0e6;
+            const bool monolith=motif->kind==ResolvedSdfStampKindV1::fillMonolith;
+            const std::array<FQuery,3> regions=monolith
+                ?std::array<FQuery,3>{{{"monolith_foot",{cx+radius-0.35,cy,floor+0.35}},
+                    {"monolith_cap",{cx+radius-0.20,cy,floor+2.0*halfZ-0.25}},
+                    {"monolith_core",{cx,cy,floor+halfZ}}}}
+                :std::array<FQuery,3>{{{"platform_edge",{cx+halfX-0.20,cy,floor+halfZ}},
+                    {"platform_corner",{cx+halfX-0.20,cy+motif->halfExtentsMicrometres[1]/1.0e6-0.20,
+                        floor+halfZ-0.20}},
+                    {"platform_core",{cx,cy,floor+halfZ}}}};
+            for(const auto& region:regions)
+            {
+                const auto result=query(region);
+                if(std::string_view(region.label).ends_with("core"))
+                {haveSolidControl|=result[0]&&!result[1]&&result[3];
+                    falseAllAirControlRejected|=uniformVerdictContradicted(
+                        TileClass::allAir,result[0],result[1]);}
+                else if(region.label==std::string_view("monolith_foot")
+                    ||region.label==std::string_view("monolith_cap")
+                    ||region.label==std::string_view("platform_edge")
+                    ||region.label==std::string_view("platform_corner"))
+                    if(!result[2]||!result[0]||!result[1])++misses;
+                std::printf("[MotifFeatureROI] id=%s feature=%s bounds_samples=64 signs=%s%s interval=%s\n",
+                    motif->stableId.c_str(),region.label,result[0]?"solid":"",
+                    result[1]?"air":"",result[2]?"mixed":"uniform");
+            }
+            const double airX=cx+halfX+8.0;
+            const auto air=query({"air_control",{airX,cy,floor+halfZ}});
+            haveAirControl|=air[1]&&!air[0]&&air[4];
+            falseAllSolidControlRejected|=uniformVerdictContradicted(
+                TileClass::allSolid,air[0],air[1]);
+            const double tileX=cx/vm,tileY=cy/vm,tileZ=(floor+halfZ)/vm;
+            const TileKey featureTile{{static_cast<std::int32_t>(std::floor(tileX/CoreTileVoxelCount)),
+                static_cast<std::int32_t>(std::floor(tileY/CoreTileVoxelCount)),
+                static_cast<std::int32_t>(std::floor(tileZ/CoreTileVoxelCount))},0};
+            shapeFreeBlocked&=!shape.isTileShapeFree(featureTile);
+        }
+        const bool passed=misses==0&&motifs.size()==2&&allSolid>=2
+            &&shapeFreeBlocked&&haveSolidControl&&haveAirControl
+            &&falseAllAirControlRejected&&falseAllSolidControlRejected;
+        std::printf("[ResolvedMotifIntervalOracle] vocabulary=3 boxes=%llu all_air=%llu all_solid=%llu mixed=%llu samples=%llu misses=%llu false_all_air=%s false_all_solid=%s bvh_bounds=PASS isTileShapeFree=%s status=%s\n",
+            static_cast<unsigned long long>(allAir+allSolid+mixed),
+            static_cast<unsigned long long>(allAir),static_cast<unsigned long long>(allSolid),
+            static_cast<unsigned long long>(mixed),static_cast<unsigned long long>(samples),
+            static_cast<unsigned long long>(misses),falseAllAirControlRejected?"REJECTED":"FAILED",
+            falseAllSolidControlRejected?"REJECTED":"FAILED",shapeFreeBlocked?"BLOCKED":"FAILED",
+            passed?"PASS":"FAIL");
+        return passed;
+    }
+
     inline int RunPipelinedStreamingBenchmark(std::shared_ptr<FStandaloneOwnerWorld> OwnerWorld,
         const VoxelForgeCore::ResolvedWorldSnapshot& CoreSnapshot,
         const FVector& CameraPositionVoxels,int32 WorkerCount,int32 MaxLevel,
@@ -1423,7 +1532,8 @@ namespace StandaloneStreamBenchmark
         const VoxelForgeCore::ResolvedLayoutSnapshotV3* ResolvedLayout=nullptr,
         bool bPrintTileHashes=false,bool bAuditLandmarkReachability=false,
         bool bAuditOreVeinYield=false,bool bAuditNativeCaves=false,
-        bool bInstrumentTileDrain=false,bool bExactMidpointDensityMemo=false,
+        bool bInstrumentTileDrain=false,bool bAuditMotifIntervals=false,
+        bool bExactMidpointDensityMemo=false,
         bool bActiveLaneBatching=false,int32 ProofBlockCells=8,
         bool bParallelSignEdgeRepair=false)
     {
@@ -1631,6 +1741,13 @@ namespace StandaloneStreamBenchmark
             {std::fprintf(stderr,"[CavesAudit] missing resolved layout\n");return 2;}
             return AuditNativeCavesField(Shape,*ResolvedLayout,World.CoreVoxelSizeMicrons)?0:14;
         }
+        if(bAuditMotifIntervals)
+        {
+            Streamer.Stop();
+            if(!ResolvedLayout||!CoreSnapshot.resolvedLayout())
+            {std::fprintf(stderr,"[ResolvedMotifIntervalOracle] missing resolved layout\n");return 2;}
+            return AuditMotifIntervals(Shape,*ResolvedLayout,World.CoreVoxelSizeMicrons)?0:14;
+        }
         if(bAuditOreVeinYield)
         {
             if(!ResolvedLayout||ResolvedLayout->oreVeins.empty())