captures: readable player-view captures with a coverage gate (L69); R36 native-generator survey

- Capture exports now cover a 90-degree player frustum (radius 3, LOD 0-8, overlap patches);
  a 17x9 ray coverage probe aborts before rendering if tiles are missing (truncated-mesh
  control: 480 uncovered samples, rejected). Clear colour is sky blue, so un-meshed space can't
  pass as dark rock. 16 views of the owner's four-strate plan.
- Explore commandlet: finite XYZ spawn override for traces (Source/, Linux-compiled).
- In-engine four-strate trace NOT obtained: the engine-generated plan fails passage validation
  at a solid centerline voxel (~(-43,-34.5,-448.5) m) while the headless owner_world.json
  plan passes. Engine and headless plans diverge.
- R36 (read-only): order TN -> VS -> FI for native migration; native FI is reachable from the
  adapter but not selected in the owner run, cause unknown.

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

Standalone/Source/LinuxOffscreenCapture.cpp

@@ -794,7 +794,9 @@ void main()
         glEnableVertexAttribArray(5);glVertexAttribPointer(5,4,GL_FLOAT,GL_FALSE,sizeof(FVertex),
             reinterpret_cast<void*>(offsetof(FVertex,Material)));
         glViewport(0,0,Width,Height);glDisable(GL_CULL_FACE);glEnable(GL_DEPTH_TEST);
-        glDepthFunc(GL_LEQUAL);glClearColor(0.035f,0.055f,0.075f,1.0f);
+        // A covered empty ray represents open air. Keep it visibly blue so it cannot
+        // be mistaken for the old near-black result from a scene that lacked tiles.
+        glDepthFunc(GL_LEQUAL);glClearColor(0.30f,0.48f,0.62f,1.0f);
         glClearDepthf(1.0f);glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
         glUseProgram(Program);
         glUniform1f(glGetUniformLocation(Program,"uTanHalfHorizontal"),static_cast<float>(TanHalfHorizontal));

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -82,6 +82,7 @@ namespace
         bool HasCamera=false;
         bool HasCameraStep=false;
         bool AutoSurfaceCamera=false;
+        bool CaptureSkipWalkability=false;
         FVector CameraMeters=FVector::ZeroVector;
         FVector CameraStepMeters=FVector::ZeroVector;
         float CameraYawDegrees=0.0f;
@@ -1410,6 +1411,7 @@ namespace
                     "  --region-crossing (compile entering Core regions at the camera step)\n"
                     "  --column-cache=shared|thread-local (default: shared)\n"
                     "  --mesh-export=FILE (write the exact generated tile meshes for offline rendering)\n"
+                    "  --capture-skip-walkability (mesh export only; defer the owner-wide passage gate)\n"
                     "  --world-assembler-manifest-output=FILE (write the canonical Core recipe and plan)\n"
                     "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                     "  --seed=N --recipe=surface-world|floating-islands|caves|lattice\n"
@@ -1589,6 +1591,7 @@ namespace
                 if(options.MeshExportPath.empty())
                 {std::fprintf(stderr,"--mesh-export needs a file path\n");return false;}
             }
+            else if(arg=="--capture-skip-walkability")options.CaptureSkipWalkability=true;
             else if(arg.starts_with("--workers="))
             {if(!readInt("--workers=",options.WorkerCount))return false;}
             else if(arg.starts_with("--clip-radius="))
@@ -1626,6 +1629,8 @@ namespace
         {std::fprintf(stderr,"--audit-ore-vein-yield requires --ore-veins-demo\n");return false;}
         if(options.LatticeRecipe&&options.LatticeStrateIndex<0)
         {std::fprintf(stderr,"--recipe=lattice requires an explicit --lattice-strate=N selection\n");return false;}
+        if(options.CaptureSkipWalkability&&options.MeshExportPath.empty())
+        {std::fprintf(stderr,"--capture-skip-walkability requires --mesh-export=FILE\n");return false;}
         if((options.AuditNativeLattice||options.LatticeOrphanControl)&&!options.LatticeRecipe)
         {std::fprintf(stderr,"native lattice audits require --recipe=lattice\n");return false;}
         if(options.TlsProbeRequested)return true;
@@ -1716,12 +1721,31 @@ int main(int argc,char** argv)
     const auto planStart=Clock::now();
     VoxelForgeCore::WorldAssemblyManifest worldAssembly;
     if(!StandaloneWorldAssemblyPrototype::AttachRound1WorldAssemblyPrototype(
-        *ownerWorld,ownerJsonRoot,error,options.WorldAssemblyManifestOutputPath.string(),&worldAssembly))
+        *ownerWorld,ownerJsonRoot,error,{},&worldAssembly))
     {std::fprintf(stderr,"World assembler prototype setup failed: %s\n",error.c_str());return 2;}
     if(options.FloatingIslandsRecipe
         &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
             *ownerWorld,ownerJsonRoot,worldAssembly,error))
     {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
+    if(!options.WorldAssemblyManifestOutputPath.empty())
+    {
+        const std::string manifestText=worldAssembly.ToJson();
+        const auto& outputPath=options.WorldAssemblyManifestOutputPath;
+        std::error_code directoryError;
+        if(!outputPath.parent_path().empty())
+            std::filesystem::create_directories(outputPath.parent_path(),directoryError);
+        if(directoryError)
+        {std::fprintf(stderr,"Could not create the complete world assembly manifest output directory.\n");return 2;}
+        std::ofstream output(outputPath,std::ios::binary);
+        if(!output)
+        {std::fprintf(stderr,"Could not open the complete world assembly manifest output path.\n");return 2;}
+        output.write(manifestText.data(),static_cast<std::streamsize>(manifestText.size()));
+        if(!output)
+        {std::fprintf(stderr,"Could not write the complete world assembly manifest payload.\n");return 2;}
+        std::printf("[WorldAssemblerFullManifest] bytes=%zu surface_strates=%zu floating_islands=%zu path=%s status=PASS\n",
+            manifestText.size(),worldAssembly.plan.strates.size(),worldAssembly.floatingIslands.size(),
+            outputPath.string().c_str());
+    }
     if (options.AuditHeightfieldProfile && !RunHeightfieldProfileAudit(worldAssembly))
     {
         std::fprintf(stderr,"Profiled SurfaceWorld interval, classification or route audit failed.\n");
@@ -2159,5 +2183,6 @@ int main(int argc,char** argv)
         options.ExactMidpointDensityMemo,options.ActiveLaneBatching,
         options.ProofBlockCells,options.HasSignEdgeRepairOverride
             ?options.ParallelSignEdgeRepair:options.FloatingIslandsRecipe,
-        options.AuditNativeLattice,options.LatticeOrphanControl);
+        options.AuditNativeLattice,options.LatticeOrphanControl,
+        options.CaptureSkipWalkability);
 }

Standalone/Source/StreamBenchmarkPipeline.h

@@ -1872,7 +1872,7 @@ namespace StandaloneStreamBenchmark
         bool bExactMidpointDensityMemo=false,
         bool bActiveLaneBatching=false,int32 ProofBlockCells=8,
         bool bParallelSignEdgeRepair=false,bool bAuditNativeLattice=false,
-        bool bLatticeOrphanControl=false)
+        bool bLatticeOrphanControl=false,bool bCaptureSkipWalkability=false)
     {
         using Clock=std::chrono::steady_clock;
         FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -2029,6 +2029,9 @@ namespace StandaloneStreamBenchmark
         ShapeRequest.detail=DetailVariant;ShapeRequest.includeFarWorld=bIncludeFarWorld;
         ShapeRequest.roundTunnels=bRoundTunnels;
         ShapeRequest.enhancedTunnelWalls=bEnhancedTunnelWalls;
+        ShapeRequest.validatePassageRoutes=!bCaptureSkipWalkability;
+        if(bCaptureSkipWalkability)
+            std::printf("[CaptureWalkabilityGate] validation=deferred geometry_input=unchanged mode=mesh-export\n");
         FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
             bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape,bProfileColumnOverlap,
             FarHorizonLOD8InteriorStepVoxels,bUseSharedColumnCache);