diff --git a/Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h b/Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h
index 8c44461..a271b75 100644
--- a/Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h
+++ b/Standalone/Core/include/VoxelForgeCore/VoxelForgeCore.h
@@ -1226,6 +1226,39 @@ namespace VoxelForgeCore
         std::vector<ResolvedLayoutPassagePointV1> controlPoints;
     };
 
+    // Passage shell, relief, smooth-max support, and rounding guard in the shared
+    // planner's integer micrometre coordinate space. Keep this aligned with the
+    // passage evaluator's L130 reach contract.
+    inline constexpr double ResolvedPassageInfluenceReachMicrometresV1 =
+        (0.75 + 0.21 + 0.50 / 6.0 + 0.01) * 1000000.0;
+    // The bounded joint covers the planner's 2 m mouth overlap and 6 m portal lead.
+    inline constexpr std::int64_t ResolvedPassageMouthJointRadiusMicrometresV1 = 8000000;
+
+    // A planner passes the conservative bounds of each layer primitive through this
+    // shared gate. Only explicitly associated mouth-joint primitives may overlap
+    // the bounded spatial joint around their named passage mouth.
+    struct ResolvedLayoutPrimitiveBoundsV1
+    {
+        std::string stableId;
+        std::int32_t strateIndex = -1;
+        std::array<std::int64_t, 3> boundsMinimumMicrometres{};
+        std::array<std::int64_t, 3> boundsMaximumMicrometres{};
+        std::string mouthJointPassageStableId;
+        std::int64_t mouthJointRadiusMicrometres = 0;
+    };
+
+    struct ResolvedLayoutPassageExclusionAuditV1
+    {
+        std::uint64_t primitivesChecked = 0;
+        std::uint64_t overlapsOutsideJoint = 0;
+        std::uint64_t mouthJointAssociations = 0;
+        std::uint32_t negativeControlsRun = 0;
+        std::uint32_t negativeControlsRejected = 0;
+        std::string firstOverlappingPrimitive;
+        std::string firstOverlappingPassage;
+        bool passed = false;
+    };
+
     struct ResolvedLayoutPassageConfigV1
     {
         std::int32_t upperStrateIndex = -1;
@@ -1340,6 +1373,14 @@ namespace VoxelForgeCore
         std::vector<ResolvedCavernRoomV1>& rooms,
         std::vector<ResolvedCavernEdgeV1>& edges,
         std::string& error);
+    VFCORE_API bool IsResolvedLayoutPrimitiveOutsidePassageEnvelopeV1(
+        const ResolvedLayoutSnapshotV3& layout,
+        const ResolvedLayoutPrimitiveBoundsV1& primitive,
+        std::string& conflictingPassageStableId);
+    VFCORE_API ResolvedLayoutPassageExclusionAuditV1
+        AuditResolvedLayoutPassageExclusionV1(
+            const ResolvedLayoutSnapshotV3& layout,
+            std::span<const ResolvedLayoutPrimitiveBoundsV1> primitives);
     VFCORE_API bool ResolveResolvedLayoutOreVeinsV1(
         ResolvedLayoutSnapshotV3& layout, std::int32_t seed,
         std::span<const ResolvedLayoutOreVeinRequestV1> requests,
diff --git a/Standalone/Core/src/ResolvedLayoutInternal.h b/Standalone/Core/src/ResolvedLayoutInternal.h
index 7b7520a..2550c77 100644
--- a/Standalone/Core/src/ResolvedLayoutInternal.h
+++ b/Standalone/Core/src/ResolvedLayoutInternal.h
@@ -2306,6 +2306,301 @@ bool ResolveResolvedCavernGraphV1(ResolvedLayoutSnapshotV3& layout,std::int32_t
     layout=std::move(candidate);return true;
 }
 
+namespace
+{
+    struct FResolvedPassageEnvelopeSegment
+    {
+        std::string stableId;
+        std::int32_t upperStrateIndex=-1,lowerStrateIndex=-1;
+        std::array<double,3> a{},b{};
+        std::array<double,3> upperMouthCenter{},lowerMouthCenter{};
+        double radiusMicrometres=0.0;
+        double alongMicrometres=0.0,lengthMicrometres=0.0,totalLengthMicrometres=0.0;
+    };
+
+    std::vector<FResolvedPassageEnvelopeSegment> BuildResolvedPassageEnvelopeSegments(
+        const ResolvedLayoutSnapshotV3& layout)
+    {
+        std::vector<FResolvedPassageEnvelopeSegment> result;
+        for(const auto& passage:layout.passages)
+        {
+            if(passage.controlPoints.size()<2||layout.coreVoxelSizeMicrometres==0)continue;
+            const std::size_t routeEnd=std::clamp<std::size_t>(
+                passage.lowerMouthControlIndex,1,passage.controlPoints.size()-1);
+            std::vector<PassageSpline::FPoint> controls;
+            controls.reserve(passage.controlPoints.size());
+            const double scale=static_cast<double>(layout.coreVoxelSizeMicrometres)
+                /WorldAssemblySubvoxelsPerVoxel;
+            for(const auto& point:passage.controlPoints)
+                controls.push_back({point.positionSubvoxels[0]*scale,
+                    point.positionSubvoxels[1]*scale,point.positionSubvoxels[2]*scale,
+                    point.radiusSubvoxels*scale});
+            const auto segments=PassageSpline::BuildSegments(controls,routeEnd,2.0,
+                1000000.0);
+            if(segments.empty())continue;
+            const double totalLength=(segments.back().alongMetres
+                +segments.back().lengthMetres)*1000000.0;
+            const std::size_t lowerMouthIndex=std::min(routeEnd,controls.size()-1);
+            for(const auto& segment:segments)
+            {
+                FResolvedPassageEnvelopeSegment envelope;
+                envelope.stableId=passage.stableId;
+                envelope.upperStrateIndex=passage.upperStrateIndex;
+                envelope.lowerStrateIndex=passage.lowerStrateIndex;
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    envelope.a[axis]=segment.a[axis];
+                    envelope.b[axis]=segment.b[axis];
+                    envelope.upperMouthCenter[axis]=controls.front()[axis];
+                    envelope.lowerMouthCenter[axis]=controls[lowerMouthIndex][axis];
+                }
+                envelope.radiusMicrometres=std::max(segment.a[3],segment.b[3]);
+                envelope.alongMicrometres=segment.alongMetres*1000000.0;
+                envelope.lengthMicrometres=segment.lengthMetres*1000000.0;
+                envelope.totalLengthMicrometres=totalLength;
+                result.push_back(std::move(envelope));
+            }
+        }
+        return result;
+    }
+
+    bool ResolvedPrimitiveBoundsOverlap(const ResolvedLayoutPrimitiveBoundsV1& primitive,
+        const std::array<double,3>& segmentA,const std::array<double,3>& segmentB,
+        double envelopeRadius)
+    {
+        std::array<double,3> direction{};
+        std::vector<double> breakpoints{0.0,1.0};
+        for(std::size_t axis=0;axis<3;++axis)
+        {
+            direction[axis]=segmentB[axis]-segmentA[axis];
+            if(std::abs(direction[axis])<=1.0e-18)continue;
+            for(const auto boundary:{static_cast<double>(primitive.boundsMinimumMicrometres[axis]),
+                static_cast<double>(primitive.boundsMaximumMicrometres[axis])})
+            {
+                const double t=(boundary-segmentA[axis])/direction[axis];
+                if(t>0.0&&t<1.0)breakpoints.push_back(t);
+            }
+        }
+        std::sort(breakpoints.begin(),breakpoints.end());
+        breakpoints.erase(std::unique(breakpoints.begin(),breakpoints.end()),
+            breakpoints.end());
+        const auto distanceSquared=[&](double t)
+        {
+            double result=0.0;
+            for(std::size_t axis=0;axis<3;++axis)
+            {
+                const double position=segmentA[axis]+direction[axis]*t;
+                const double gap=position<primitive.boundsMinimumMicrometres[axis]
+                    ?primitive.boundsMinimumMicrometres[axis]-position
+                    :position>primitive.boundsMaximumMicrometres[axis]
+                        ?position-primitive.boundsMaximumMicrometres[axis]:0.0;
+                result+=gap*gap;
+            }
+            return result;
+        };
+        double closestSquared=std::min(distanceSquared(0.0),distanceSquared(1.0));
+        for(std::size_t index=1;index<breakpoints.size();++index)
+        {
+            const double low=breakpoints[index-1],high=breakpoints[index];
+            const double middle=(low+high)*0.5;
+            double quadratic=0.0,linear=0.0;
+            for(std::size_t axis=0;axis<3;++axis)
+            {
+                const double position=segmentA[axis]+direction[axis]*middle;
+                double boundary=0.0;
+                bool active=false;
+                if(position<primitive.boundsMinimumMicrometres[axis])
+                {boundary=primitive.boundsMinimumMicrometres[axis];active=true;}
+                else if(position>primitive.boundsMaximumMicrometres[axis])
+                {boundary=primitive.boundsMaximumMicrometres[axis];active=true;}
+                if(!active)continue;
+                quadratic+=direction[axis]*direction[axis];
+                linear+=direction[axis]*(segmentA[axis]-boundary);
+            }
+            if(quadratic>1.0e-18)
+            {
+                const double closest=std::clamp(-linear/quadratic,low,high);
+                closestSquared=std::min(closestSquared,distanceSquared(closest));
+            }
+            closestSquared=std::min(closestSquared,distanceSquared(low));
+            closestSquared=std::min(closestSquared,distanceSquared(high));
+        }
+        return closestSquared<=envelopeRadius*envelopeRadius;
+    }
+}
+
+bool IsResolvedLayoutPrimitiveOutsidePassageEnvelopeV1(
+    const ResolvedLayoutSnapshotV3& layout,
+    const ResolvedLayoutPrimitiveBoundsV1& primitive,
+    std::string& conflictingPassageStableId)
+{
+    conflictingPassageStableId.clear();
+    for(std::size_t axis=0;axis<3;++axis)
+        if(primitive.boundsMinimumMicrometres[axis]
+                >primitive.boundsMaximumMicrometres[axis])
+        {conflictingPassageStableId="invalid-primitive-bounds";return false;}
+    if(primitive.mouthJointRadiusMicrometres<0
+        ||primitive.mouthJointRadiusMicrometres
+            >ResolvedPassageMouthJointRadiusMicrometresV1)
+    {conflictingPassageStableId="invalid-mouth-joint-radius";return false;}
+
+    const auto envelope=BuildResolvedPassageEnvelopeSegments(layout);
+    bool matchedMouthJoint=primitive.mouthJointPassageStableId.empty();
+    for(const auto& segment:envelope)
+    {
+        const bool isUpper=primitive.strateIndex==segment.upperStrateIndex;
+        const bool isLower=primitive.strateIndex==segment.lowerStrateIndex;
+        if(!isUpper&&!isLower)continue;
+        const bool authorized=primitive.mouthJointPassageStableId==segment.stableId;
+        if(authorized)matchedMouthJoint=true;
+        const double radius=segment.radiusMicrometres
+            +ResolvedPassageInfluenceReachMicrometresV1+1000.0;
+        const auto rejectAt=[&](double t)
+        {
+            conflictingPassageStableId=segment.stableId;
+            const std::array<double,3> center{
+                std::lerp(segment.a[0],segment.b[0],t),
+                std::lerp(segment.a[1],segment.b[1],t),
+                std::lerp(segment.a[2],segment.b[2],t)};
+            const auto mouthDistance=[&](const auto& mouth)
+            {
+                const double dx=center[0]-mouth[0],dy=center[1]-mouth[1],
+                    dz=center[2]-mouth[2];
+                return std::sqrt(dx*dx+dy*dy+dz*dz)/1.0e6;
+            };
+            std::printf("[PassageExclusionConflictDetail] primitive=%s passage=%s station_m=%.3f authorized_joint=%s joint_radius_m=%.3f envelope_radius_m=%.3f nearest_mouth_m=%.3f center_m=(%.3f,%.3f,%.3f) bounds_min_m=(%.3f,%.3f,%.3f) bounds_max_m=(%.3f,%.3f,%.3f)\n",
+                primitive.stableId.c_str(),segment.stableId.c_str(),
+                (segment.alongMicrometres+segment.lengthMicrometres*t)/1.0e6,
+                authorized?"true":"false",
+                primitive.mouthJointRadiusMicrometres/1.0e6,radius/1.0e6,
+                std::min(mouthDistance(segment.upperMouthCenter),
+                    mouthDistance(segment.lowerMouthCenter)),
+                center[0]/1.0e6,center[1]/1.0e6,center[2]/1.0e6,
+                primitive.boundsMinimumMicrometres[0]/1.0e6,
+                primitive.boundsMinimumMicrometres[1]/1.0e6,
+                primitive.boundsMinimumMicrometres[2]/1.0e6,
+                primitive.boundsMaximumMicrometres[0]/1.0e6,
+                primitive.boundsMaximumMicrometres[1]/1.0e6,
+                primitive.boundsMaximumMicrometres[2]/1.0e6);
+            return false;
+        };
+        const auto overlaps=[&](double t0,double t1)
+        {
+            if(t1<=t0)return false;
+            std::array<double,3> a{},b{};
+            for(std::size_t axis=0;axis<3;++axis)
+            {
+                a[axis]=std::lerp(segment.a[axis],segment.b[axis],t0);
+                b[axis]=std::lerp(segment.a[axis],segment.b[axis],t1);
+            }
+            return ResolvedPrimitiveBoundsOverlap(primitive,a,b,radius);
+        };
+        if(authorized&&primitive.mouthJointRadiusMicrometres>0)
+        {
+            const auto& center=isUpper?segment.upperMouthCenter:segment.lowerMouthCenter;
+            std::array<double,3> delta{};
+            double quadratic=0.0,linear=0.0,constant=0.0;
+            for(std::size_t axis=0;axis<3;++axis)
+            {
+                delta[axis]=segment.b[axis]-segment.a[axis];
+                const double offset=segment.a[axis]-center[axis];
+                quadratic+=delta[axis]*delta[axis];
+                linear+=offset*delta[axis];
+                constant+=offset*offset;
+            }
+            const double jointReach=primitive.mouthJointRadiusMicrometres+radius;
+            constant-=jointReach*jointReach;
+            const double discriminant=linear*linear-quadratic*constant;
+            if(quadratic<=1.0e-18)
+            {
+                // A degenerate segment that is wholly in the joint is authorized;
+                // one outside it remains subject to the full envelope check.
+                if(constant<=0.0)continue;
+                if(overlaps(0.0,1.0))
+                    return rejectAt(0.5);
+                continue;
+            }
+            if(discriminant<0.0)
+            {
+                if(overlaps(0.0,1.0))
+                    return rejectAt(0.5);
+                continue;
+            }
+            const double root=std::sqrt(discriminant);
+            const double insideFirst=(-linear-root)/quadratic;
+            const double insideLast=(-linear+root)/quadratic;
+            const double clippedFirst=std::clamp(insideFirst,0.0,1.0);
+            const double clippedLast=std::clamp(insideLast,0.0,1.0);
+            if(insideFirst>=1.0||insideLast<=0.0)
+            {
+                if(overlaps(0.0,1.0))
+                    return rejectAt(0.5);
+                continue;
+            }
+            if(overlaps(0.0,clippedFirst)||overlaps(clippedLast,1.0))
+                return rejectAt(clippedFirst>0.0?clippedFirst*0.5:
+                    (1.0+clippedLast)*0.5);
+            continue;
+        }
+        if(overlaps(0.0,1.0))
+            return rejectAt(0.5);
+    }
+    if(!matchedMouthJoint)
+    {conflictingPassageStableId=primitive.mouthJointPassageStableId;return false;}
+    return true;
+}
+
+ResolvedLayoutPassageExclusionAuditV1 AuditResolvedLayoutPassageExclusionV1(
+    const ResolvedLayoutSnapshotV3& layout,
+    std::span<const ResolvedLayoutPrimitiveBoundsV1> primitives)
+{
+    ResolvedLayoutPassageExclusionAuditV1 result;
+    for(const auto& primitive:primitives)
+    {
+        ++result.primitivesChecked;
+        if(!primitive.mouthJointPassageStableId.empty())
+            ++result.mouthJointAssociations;
+        std::string conflict;
+        if(!IsResolvedLayoutPrimitiveOutsidePassageEnvelopeV1(layout,primitive,conflict))
+        {
+            ++result.overlapsOutsideJoint;
+            if(result.firstOverlappingPrimitive.empty())
+            {
+                result.firstOverlappingPrimitive=primitive.stableId;
+                result.firstOverlappingPassage=std::move(conflict);
+            }
+        }
+    }
+
+    const auto passage=std::find_if(layout.passages.begin(),layout.passages.end(),
+        [](const auto& value){return value.controlPoints.size()>=2;});
+    if(passage!=layout.passages.end()&&layout.coreVoxelSizeMicrometres>0)
+    {
+        const auto& point=passage->controlPoints[passage->controlPoints.size()/2]
+            .positionSubvoxels;
+        ResolvedLayoutPrimitiveBoundsV1 control;
+        control.stableId="negative-control/forced-inside-passage-envelope";
+        control.strateIndex=passage->lowerStrateIndex;
+        const double scale=static_cast<double>(layout.coreVoxelSizeMicrometres)
+            /WorldAssemblySubvoxelsPerVoxel;
+        for(std::size_t axis=0;axis<3;++axis)
+        {
+            const auto center=static_cast<std::int64_t>(std::llround(point[axis]*scale));
+            control.boundsMinimumMicrometres[axis]=center-250000;
+            control.boundsMaximumMicrometres[axis]=center+250000;
+        }
+        ++result.negativeControlsRun;
+        std::string conflict;
+        if(!IsResolvedLayoutPrimitiveOutsidePassageEnvelopeV1(layout,control,conflict)
+            &&conflict==passage->stableId)
+            ++result.negativeControlsRejected;
+    }
+    result.passed=result.overlapsOutsideJoint==0
+        &&result.negativeControlsRun==1
+        &&result.negativeControlsRejected==result.negativeControlsRun;
+    return result;
+}
+
 bool PlanResolvedCavernNetworkV1(const ResolvedLayoutSnapshotV3& layout,
     std::int32_t seed,std::int32_t strateIndex,
     const ResolvedCavernPlannerSettingsV1& settings,
@@ -3484,6 +3779,127 @@ bool PlanResolvedCavernNetworkV1(const ResolvedLayoutSnapshotV3& layout,
             std::atan2(static_cast<double>(rise),static_cast<double>(run))
                 *180.0/3.14159265358979323846);
     }
+    auto boundedGraph=layout;
+    std::string boundsError;
+    if(!ResolveResolvedCavernGraphV1(boundedGraph,seed,rooms,edges,boundsError))
+    {error="cavern planner could not validate primitive bounds: "+boundsError;return false;}
+    std::vector<ResolvedLayoutPrimitiveBoundsV1> primitiveBounds;
+    primitiveBounds.reserve(boundedGraph.cavernRooms.size()+boundedGraph.cavernEdges.size());
+    const std::int64_t mouthJointFeatureSpanMicrometres=
+        MouthOverlap+PortalLeadLength+2*settings.destinationRadiusMicrometres;
+    const auto mouthJointAtProfileDistance=[&](std::int64_t distance)
+        ->std::string
+    {
+        if(distance<=mouthJointFeatureSpanMicrometres)
+            return arrivalPassage->stableId;
+        if(departurePassage&&totalRouteLength-distance
+                <=mouthJointFeatureSpanMicrometres)
+            return departurePassage->stableId;
+        return {};
+    };
+    const auto associateSpatialMouthJoint=[&](ResolvedLayoutPrimitiveBoundsV1& bounds)
+    {
+        if(!bounds.mouthJointPassageStableId.empty())return;
+        const double jointRadius=
+            static_cast<double>(ResolvedPassageMouthJointRadiusMicrometresV1);
+        double nearestSquared=jointRadius*jointRadius;
+        for(const auto& passage:layout.passages)
+        {
+            if(bounds.strateIndex!=passage.upperStrateIndex
+                &&bounds.strateIndex!=passage.lowerStrateIndex)
+                continue;
+            if(passage.controlPoints.size()<2)continue;
+            const std::size_t lowerMouthIndex=std::min(
+                passage.lowerMouthControlIndex,passage.controlPoints.size()-1);
+            const std::array<std::size_t,2> mouthIndices={0,lowerMouthIndex};
+            double passageDistanceSquared=std::numeric_limits<double>::infinity();
+            for(const auto mouthIndex:mouthIndices)
+            {
+                double distanceSquared=0.0;
+                for(std::size_t axis=0;axis<3;++axis)
+                {
+                    const double center=static_cast<double>(qToMicrometres(
+                        passage.controlPoints[mouthIndex].positionSubvoxels[axis]));
+                    const double gap=center<bounds.boundsMinimumMicrometres[axis]
+                        ?bounds.boundsMinimumMicrometres[axis]-center
+                        :center>bounds.boundsMaximumMicrometres[axis]
+                            ?center-bounds.boundsMaximumMicrometres[axis]:0.0;
+                    distanceSquared+=gap*gap;
+                }
+                passageDistanceSquared=std::min(passageDistanceSquared,distanceSquared);
+            }
+            if(passageDistanceSquared<=nearestSquared)
+            {
+                if(bounds.mouthJointPassageStableId.empty()
+                    ||passageDistanceSquared<nearestSquared
+                    ||passage.stableId<bounds.mouthJointPassageStableId)
+                {
+                    bounds.mouthJointPassageStableId=passage.stableId;
+                    nearestSquared=passageDistanceSquared;
+                }
+            }
+        }
+        if(!bounds.mouthJointPassageStableId.empty())
+            bounds.mouthJointRadiusMicrometres=
+                ResolvedPassageMouthJointRadiusMicrometresV1;
+    };
+    for(const auto& room:boundedGraph.cavernRooms)
+    {
+        ResolvedLayoutPrimitiveBoundsV1 bounds{room.stableId,room.strateIndex,
+            room.boundsMinimumMicrometres,room.boundsMaximumMicrometres};
+        if(room.floorProfileStableId==backboneFloorProfileId
+            &&room.floorProfileDistanceMicrometres>=0)
+            bounds.mouthJointPassageStableId=mouthJointAtProfileDistance(
+                room.floorProfileDistanceMicrometres);
+        if(!bounds.mouthJointPassageStableId.empty())
+            bounds.mouthJointRadiusMicrometres=
+                ResolvedPassageMouthJointRadiusMicrometresV1;
+        associateSpatialMouthJoint(bounds);
+        primitiveBounds.push_back(std::move(bounds));
+    }
+    const auto mouthJointForAnchor=[](const std::string& anchor)
+    {
+        constexpr std::string_view Lower="/lower-mouth";
+        constexpr std::string_view Upper="/upper-mouth";
+        if(anchor.ends_with(Lower))return anchor.substr(0,anchor.size()-Lower.size());
+        if(anchor.ends_with(Upper))return anchor.substr(0,anchor.size()-Upper.size());
+        return std::string{};
+    };
+    for(const auto& edge:boundedGraph.cavernEdges)
+    {
+        ResolvedLayoutPrimitiveBoundsV1 bounds{edge.stableId,edge.strateIndex,
+            edge.boundsMinimumMicrometres,edge.boundsMaximumMicrometres};
+        bounds.mouthJointPassageStableId=mouthJointForAnchor(edge.startAnchorStableId);
+        if(bounds.mouthJointPassageStableId.empty()
+            &&edge.floorProfileStableId==backboneFloorProfileId
+            &&edge.floorProfileStartDistanceMicrometres>=0
+            &&edge.floorProfileEndDistanceMicrometres>=0)
+        {
+            const auto midpoint=(edge.floorProfileStartDistanceMicrometres
+                +edge.floorProfileEndDistanceMicrometres)/2;
+            bounds.mouthJointPassageStableId=mouthJointAtProfileDistance(midpoint);
+        }
+        if(!bounds.mouthJointPassageStableId.empty())
+            bounds.mouthJointRadiusMicrometres=
+                ResolvedPassageMouthJointRadiusMicrometresV1;
+        associateSpatialMouthJoint(bounds);
+        primitiveBounds.push_back(std::move(bounds));
+    }
+    const auto exclusionAudit=AuditResolvedLayoutPassageExclusionV1(layout,primitiveBounds);
+    std::printf("[CavernPassageExclusionAudit] strate=%d primitives=%llu outside_joint=%llu mouth_joint=%llu negative_controls=%u/%u first_primitive=%s first_passage=%s status=%s\n",
+        strateIndex,static_cast<unsigned long long>(exclusionAudit.primitivesChecked),
+        static_cast<unsigned long long>(exclusionAudit.overlapsOutsideJoint),
+        static_cast<unsigned long long>(exclusionAudit.mouthJointAssociations),
+        exclusionAudit.negativeControlsRejected,exclusionAudit.negativeControlsRun,
+        exclusionAudit.firstOverlappingPrimitive.empty()?"none":exclusionAudit.firstOverlappingPrimitive.c_str(),
+        exclusionAudit.firstOverlappingPassage.empty()?"none":exclusionAudit.firstOverlappingPassage.c_str(),
+        exclusionAudit.passed?"PASS":"FAIL");
+    if(!exclusionAudit.passed)
+    {
+        error="cavern planner primitive bounds overlap a passage exclusion envelope outside its mouth joint: "+
+            exclusionAudit.firstOverlappingPrimitive+" -> "+exclusionAudit.firstOverlappingPassage;
+        return false;
+    }
     const double plannerMilliseconds=std::chrono::duration<double,std::milli>(
         std::chrono::steady_clock::now()-plannerStarted).count();
     std::printf("[CavernPlannerV1] strate=%d seed=%d route=%s->%s route_nodes=%zu room_primitives=%zu shafts=%zu edges=%zu branches=%zu route_horizontal_m=%.3f floor_delta_m=%.3f max_grade_deg=%.3f mouth_tangent_min_dot=%.3f grade_limit_deg=11.310 clearance_radius_m=%.3f clearance_height_m=%.3f destination_radius_m=%.3f plan_ms=%.3f status=PASS\n",
diff --git a/Standalone/Source/StreamBenchmarkPipeline.h b/Standalone/Source/StreamBenchmarkPipeline.h
index 48b5a30..80677e3 100644
--- a/Standalone/Source/StreamBenchmarkPipeline.h
+++ b/Standalone/Source/StreamBenchmarkPipeline.h
@@ -4709,6 +4709,19 @@ namespace StandaloneStreamBenchmark
                 const auto& route=allPassageSmoothRoutes[passageIndex];
                 if(route.size()<2)return audit;
                 const double totalRouteLength=route.back().distance;
+                const double mouthJointRadiusMetres=
+                    static_cast<double>(VoxelForgeCore::
+                        ResolvedPassageMouthJointRadiusMicrometresV1)/1000000.0;
+                const auto insideMouthJoint=[&](double x,double y,double z)
+                {
+                    const auto inside=[&](const auto& mouth)
+                    {
+                        const double dx=x-mouth.x,dy=y-mouth.y,dz=z-mouth.z;
+                        return dx*dx+dy*dy+dz*dz
+                            <=mouthJointRadiusMetres*mouthJointRadiusMetres;
+                    };
+                    return inside(route.front())||inside(route.back());
+                };
                 const double bodyFloorDepth=allPassageBodyFloorDepths[passageIndex];
                 constexpr std::array<std::array<double,2>,5> floorOffsets{{
                     {{0.0,0.0}},{{0.30,0.0}},{{-0.30,0.0}},
@@ -4859,11 +4872,6 @@ namespace StandaloneStreamBenchmark
                         }
                         const double tangentLength=std::hypot(dx,dy);
                         if(tangentLength<=1.0e-6)continue;
-                        if(std::min(along,totalRouteLength-along)<5.0)
-                        {
-                            audit.wallMouthBlendSkips+=5;
-                            continue;
-                        }
                         const double nx=-dy/tangentLength,ny=dx/tangentLength;
                         const double floorDepth=passageTubeDepthAt(radius,bodyFloorDepth);
                         double floorZ=passageFloorAtXY(passageIndex,centerX,centerY,
@@ -4897,6 +4905,11 @@ namespace StandaloneStreamBenchmark
                                 }
                                 sampleZ=floorZ+probe.height;
                             }
+                            if(insideMouthJoint(sampleX,sampleY,sampleZ))
+                            {
+                                ++audit.wallMouthBlendSkips;
+                                continue;
+                            }
                             const VoxelForgeCore::Vec3d wallPosition{sampleX/coreMetres,
                                 sampleY/coreMetres,sampleZ/coreMetres};
                             if(passageInteriorWinsAt(sampleX,sampleY,sampleZ))