fix(core): smooth tunnel entrance floor; verifier keeps baselines out of /tmp (L47); research R14

The demo tunnel's hard floor cap used a vertical Z - floorZ on a sloped Bezier floor, which is not a signed
distance, so marching cubes produced a staircase through the first 7 m (40-51 mm ripple, 82 mm steps). The
cap now uses the grade-normalised signed distance with a floor-adjacent bore re-application fading over the
entrance; mesh tile Z bounds include cavern bounds. New three-rail entrance audit: L46 fails, L47 passes.
verify: the cost baseline exports only build inputs into Saved/Linux/<out>/baseline-<commit> and removes it;
/tmp unchanged after a full tier. Demo off: owner hashes identical to L46. fast/medium/full PASS.
Known: sawtooth at the tunnel wall foot (next round). Research R14: Windows/MSVC readiness review.

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -504,8 +504,12 @@ namespace StandaloneStreamBenchmark
 
     struct FLandmarkTunnelRippleResult
     {
-        std::size_t floorSamples=0,wallSamples=0;
+        std::size_t floorSamples=0,entranceFloorSamples=0,wallSamples=0;
         double floorPeakPeriodMetres=0.0,floorPeakAmplitudeMetres=0.0;
+        double entranceFloorMaxStepMetres=0.0;
+        double entranceFloorWorstDistanceMetres=0.0;
+        double entranceFloorPriorResidualMetres=0.0,entranceFloorCurrentResidualMetres=0.0;
+        std::size_t entranceFloorWorstTrack=0;
         double wallPeakPeriodMetres=0.0,wallPeakAmplitudeMetres=0.0;
         bool valid=false,passed=false;
     };
@@ -601,7 +605,11 @@ namespace StandaloneStreamBenchmark
             return closest;
         };
         std::vector<std::pair<double,double>> floorResiduals;
-        for(double distance=0.75;distance<=length-0.75;distance+=0.125)
+        std::array<std::vector<std::pair<double,double>>,3> floorTrackResiduals;
+        std::array<std::optional<double>,3> previousFloorResiduals;
+        std::array<double,3> previousFloorDistances{};
+        constexpr std::array<double,3> FloorTrackOffsets={-1.5,0.0,1.5};
+        for(double distance=0.0;distance<=length-0.75;distance+=0.125)
         {
             const auto point=atDistance(distance);
             const auto prior=atDistance(std::max(0.0,distance-0.1));
@@ -611,16 +619,40 @@ namespace StandaloneStreamBenchmark
             if(tangentLength<1.0e-6)continue;
             const double normalX=-ty/tangentLength,normalY=tx/tangentLength;
             double offsetSum=0.0;std::size_t offsetCount=0;
-            for(const double lateral:{-0.35,0.0,0.35})
+            for(std::size_t track=0;track<FloorTrackOffsets.size();++track)
             {
+                const double lateral=FloorTrackOffsets[track];
                 const auto root=floorRoot(point.x+normalX*lateral,
                     point.y+normalY*lateral,point.floor);
-                if(root){offsetSum+=*root-point.floor;++offsetCount;}
+                if(!root)continue;
+                const double residual=*root-point.floor;
+                floorTrackResiduals[track].push_back({distance,residual});
+                offsetSum+=residual;++offsetCount;
+                if(distance<=10.0+1.0e-9)
+                {
+                    ++result.entranceFloorSamples;
+                    if(previousFloorResiduals[track]
+                        &&distance-previousFloorDistances[track]<=0.2)
+                    {
+                        const double step=std::abs(residual-*previousFloorResiduals[track]);
+                        if(step>result.entranceFloorMaxStepMetres)
+                        {
+                            result.entranceFloorMaxStepMetres=step;
+                            result.entranceFloorWorstDistanceMetres=distance;
+                            result.entranceFloorPriorResidualMetres=*previousFloorResiduals[track];
+                            result.entranceFloorCurrentResidualMetres=residual;
+                            result.entranceFloorWorstTrack=track;
+                        }
+                    }
+                }
+                previousFloorResiduals[track]=residual;
+                previousFloorDistances[track]=distance;
             }
             if(offsetCount)
             {floorResiduals.push_back({distance,offsetSum/offsetCount});}
         }
-        result.floorSamples=floorResiduals.size();
+        result.floorSamples=floorTrackResiduals[0].size()
+            +floorTrackResiduals[1].size()+floorTrackResiduals[2].size();
         const auto peakPeriod=[&](const std::vector<std::pair<double,double>>& samples,
                                   double minimumPeriod,double maximumPeriod,
                                   double& outPeriod)
@@ -642,6 +674,17 @@ namespace StandaloneStreamBenchmark
         };
         result.floorPeakAmplitudeMetres=peakPeriod(floorResiduals,0.375,
             std::min(8.0,length/2.0),result.floorPeakPeriodMetres);
+        for(const auto& track:floorTrackResiduals)
+        {
+            double trackPeriod=0.0;
+            const double trackAmplitude=peakPeriod(track,0.375,
+                std::min(8.0,length/2.0),trackPeriod);
+            if(trackAmplitude>result.floorPeakAmplitudeMetres)
+            {
+                result.floorPeakAmplitudeMetres=trackAmplitude;
+                result.floorPeakPeriodMetres=trackPeriod;
+            }
+        }
 
         std::vector<std::pair<double,double>> wallResiduals;
         const double expectedWallRadius=edge!=layout.cavernEdges.end()
@@ -702,8 +745,10 @@ namespace StandaloneStreamBenchmark
         }
         result.wallPeakAmplitudeMetres=peakPeriod(wallRippleResiduals,0.25,
             std::min(1.0,length/2.0),result.wallPeakPeriodMetres);
-        result.valid=result.floorSamples>=16&&result.wallSamples>=16;
+        result.valid=result.floorSamples>=16&&result.entranceFloorSamples>=150
+            &&result.wallSamples>=16;
         result.passed=result.valid&&result.floorPeakAmplitudeMetres<=0.015
+            &&result.entranceFloorMaxStepMetres<=0.05
             &&result.wallPeakAmplitudeMetres<=0.035;
         return result;
     }
@@ -1259,6 +1304,16 @@ namespace StandaloneStreamBenchmark
             {std::fprintf(stderr,"[LandmarkReachabilityAudit] missing cavern room node\n");return 2;}
             const auto ripples=AuditLandmarkTunnelRipples(Shape,*ResolvedLayout,
                 World.CoreVoxelSizeMicrons);
+            const bool entranceFloorPassed=ripples.entranceFloorSamples>=150
+                &&ripples.entranceFloorMaxStepMetres<=0.05
+                &&ripples.floorPeakAmplitudeMetres<=0.015;
+            std::printf("[CavernEntranceFloorAudit] layout=L46 samples=%zu distance_m=0.000..10.000 rails=3 max_step_m=%.4f step_limit_m=0.050 ripple_peak_m=%.4f ripple_limit_m=0.015 status=%s\n",
+                ripples.entranceFloorSamples,ripples.entranceFloorMaxStepMetres,
+                ripples.floorPeakAmplitudeMetres,entranceFloorPassed?"PASS":"FAIL");
+            std::printf("[CavernEntranceFloorStepDetail] rail=%zu distance_m=%.3f residual_m=%.4f->%.4f\n",
+                ripples.entranceFloorWorstTrack,ripples.entranceFloorWorstDistanceMetres,
+                ripples.entranceFloorPriorResidualMetres,
+                ripples.entranceFloorCurrentResidualMetres);
             std::printf("[CavernTunnelRipple] layout=L46 floor_samples=%zu floor_peak_period_m=%.3f floor_peak_amplitude_m=%.4f floor_limit_m=0.015 wall_samples=%zu wall_peak_period_m=%.3f wall_peak_amplitude_m=%.4f wall_period_band_m=0.250..1.000 wall_detrend_window_m=2.000 wall_limit_m=0.035 status=%s\n",
                 ripples.floorSamples,ripples.floorPeakPeriodMetres,
                 ripples.floorPeakAmplitudeMetres,ripples.wallSamples,
@@ -1318,7 +1373,8 @@ namespace StandaloneStreamBenchmark
                 static_cast<unsigned long long>(buried.unsupportedSamples),
                 static_cast<unsigned long long>(buried.gradeFailures),
                 buried.passed?"PASS":"FAIL",buried.passed?"FAIL":"PASS");
-            const bool passed=ripples.passed&&candidate.passed&&!buried.passed;
+            const bool passed=ripples.passed&&entranceFloorPassed
+                &&candidate.passed&&!buried.passed;
             std::printf("[LandmarkReachabilityAudit] positive=PASS control=%s status=%s\n",
                 buried.passed?"FAILED":"EXPECTED_FAIL",passed?"PASS":"FAIL");
             return passed?0:13;