fix(physics): S2 — static publication emits authored Spheres as Spheres (AP-155 narrowed)

Both static sites (LandblockPhysicsPublisher, the headless-only
LandblockPhysicsContentBuilder) emitted an authored Setup Sphere as a
base-anchored Cylinder of radius r and height 2r. The live path emits a
Sphere for the same data, so the same object collided differently by
arrival route, and the narrow phase met a flat cap where retail meets a
curved surface. Both sites now mirror ShadowShapeBuilder.FromSetup's
Sphere block exactly.

Combined Opus review: PASS. Its numeric verification of the dispatch
test's geometry (head-sphere clearance 0.201 m for the true sphere; the
cylinder counterfactual inside by 0.10 m XY with the Z band overlapping)
is what makes the discrimination claim more than a sabotage anecdote,
and its F8 finding is applied: the test now carries a POSITIVE control —
aiming straight through the boulder's centre must block — so a
membership/seed regression can no longer masquerade as a curve-hit
pass. F4 applied: CylHeight is asserted, not inferred (the C4 lesson).
F3 applied: the deleted Quaternion.Inverse base composition is recorded
as internally coherent for the old cylinder's world-Z axis — the defect
was the shape TYPE, not that rotation math.

The review also verified the deleted-cylinder blast radius: the F2
overlay's drawn span is IDENTICAL for both shapes (old [c-r, c+r], new
[c-r, c+r]); the flood sphere's centre rises by exactly r, which cannot
change outdoor membership (XY rectangle) and lands the indoor half on
Session B's dungeon gate alongside S1B; and the sphere-branch flood is
now pinned uncapped by a genuine eleventh-shape A/B test.
PublishStaticCollision — the headless static path — gains its first
test ever.

AP-155 is NARROWED, not deleted (review F13): the has-BSP source split
(entity.MeshRefs vs setup.Parts + AnimPartChanged) survives and keeps
the row active. The shared-primitive-emitter refactor that would make
route independence a compile-time property is the filed follow-up
(review F20).

Population: 3,506 of 5,935 installed Setups, structurally equal to
AP-157's third-branch count (byte-identical classifier — three
independent routes agree: 3,605 - 99 = 3,506).

Clean-room suite at implementation: 11,253 passed / 6 skipped / 0
failed on landed S1B. Post-review-hardening: Publisher tests 25/25,
Content tests 2/2, both green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/AcDream.App.Tests/Streaming/LandblockPhysicsPublisherTests.cs

@@ -462,6 +462,186 @@ public sealed class LandblockPhysicsPublisherTests
         Assert.Equal(0, fixture.Publisher.Diagnostics.StaticCylinderOwnerCount);
     }
 
+    /// <summary>
+    /// AP-155 parity (route independence). A Setup carrying only authored
+    /// Spheres (no CylSpheres) must register the SAME shapes — type, local
+    /// position, radius, scale — through the static publication path as
+    /// through <see cref="ShadowShapeBuilder.FromSetup"/>, the LIVE path.
+    /// Before the fix this site emitted a height-capped Cylinder instead
+    /// (base = origin - r*ẑ, height = 2r): same object, different narrow
+    /// phase depending on how it arrived.
+    /// </summary>
+    [Fact]
+    public void CompletePublication_SphereOnlySetup_MatchesFromSetupShapeForShape()
+    {
+        var fixture = Fixture();
+        var setup = new Setup();
+        setup.Spheres.Add(new Sphere
+        {
+            Origin = new Vector3(0.3f, -0.2f, 0.9f),
+            Radius = 0.55f,
+        });
+        setup.Spheres.Add(new Sphere
+        {
+            Origin = new Vector3(-0.1f, 0.4f, 1.4f),
+            Radius = 0.25f,
+        });
+        fixture.Cache.CacheSetup(SetupId, setup);
+
+        const float entScale = 1.3f;
+        WorldEntity entity = new()
+        {
+            Id = 0x80A9B401u,
+            SourceGfxObjOrSetupId = SetupId,
+            Position = Vector3.Zero,
+            Rotation = Quaternion.Identity,
+            Scale = entScale,
+            MeshRefs = Array.Empty<MeshRef>(),
+        };
+
+        Publish(fixture.Publisher, Build(FirstLandblock, [entity]));
+
+        // The LIVE-path oracle for the SAME Setup/scale.
+        IReadOnlyList<ShadowShape> expected =
+            ShadowShapeBuilder.FromSetup(setup, entScale, _ => false);
+        Assert.Equal(2, expected.Count);
+        Assert.All(
+            expected,
+            shape => Assert.Equal(ShadowCollisionType.Sphere, shape.CollisionType));
+
+        ShadowShape[] expectedOrdered =
+            expected.OrderBy(shape => shape.Radius).ToArray();
+        // Entity registered at world origin with identity rotation, so
+        // RegisterMultiPart's world composition (entityWorldPos +
+        // Transform(shape.LocalPosition, entityWorldRot)) reduces to exactly
+        // shape.LocalPosition — the static entry's world Position is directly
+        // comparable to FromSetup's LocalPosition.
+        ShadowEntry[] entries = fixture.Engine.ShadowObjects.AllEntriesForDebug()
+            .Where(entry => entry.EntityId == entity.Id)
+            .OrderBy(entry => entry.Radius)
+            .ToArray();
+
+        Assert.Equal(expectedOrdered.Length, entries.Length);
+        for (int i = 0; i < entries.Length; i++)
+        {
+            Assert.Equal(ShadowCollisionType.Sphere, entries[i].CollisionType);
+            Assert.Equal(expectedOrdered[i].LocalPosition, entries[i].Position);
+            Assert.Equal(expectedOrdered[i].Radius, entries[i].Radius);
+            Assert.Equal(expectedOrdered[i].Scale, entries[i].Scale);
+            // Review F4 (2026-08-07): assert, don't infer — the C4 lesson.
+            Assert.Equal(expectedOrdered[i].CylHeight, entries[i].CylHeight);
+        }
+    }
+
+    /// <summary>
+    /// AP-155 dispatch. A statically-published Sphere must actually run the
+    /// Sphere narrow phase (<c>CSphere::intersects_sphere</c> — true 3-D
+    /// distance) at query time, not the Cylinder narrow phase (XY distance +
+    /// flat Z-band). Geometry: a 1 m-radius "boulder" Setup Sphere centred at
+    /// world Z=2.0 (spans Z=[1,3]). A tall, narrow capsule mover's HEAD sphere
+    /// grazes the boulder's shoulder at Z~2.85 (0.85 m above the boulder's own
+    /// centre, out of its 1 m radius) with a 1.05 m lateral offset; its FOOT
+    /// sphere (Z~0.15) never comes close. At that height/offset the true
+    /// sphere's surface has tapered well inside the mover's path (curve-hit —
+    /// clean miss, ~0.2 m 3-D clearance), while the retired flat-capped
+    /// Cylinder never tapers and still fills the same footprint the whole
+    /// height of its cap (cap-hit — the 1.05 m offset sits ~0.10 m inside its
+    /// XY radius). The two verdicts differ; this asserts the Sphere one —
+    /// unobstructed straight-line arrival at the far side.
+    /// </summary>
+    [Fact]
+    public void CompletePublication_SphereOnlySetup_MoverGrazesShoulderAndPassesThroughUnobstructed()
+    {
+        var fixture = Fixture();
+        var setup = new Setup();
+        setup.Spheres.Add(new Sphere
+        {
+            Origin = new Vector3(0f, 0f, 2.0f),
+            Radius = 1.0f,
+        });
+        fixture.Cache.CacheSetup(SetupId, setup);
+
+        WorldEntity entity = new()
+        {
+            Id = 0x80A9B401u,
+            SourceGfxObjOrSetupId = SetupId,
+            Position = new Vector3(12f, 12f, 0f),
+            Rotation = Quaternion.Identity,
+            MeshRefs = Array.Empty<MeshRef>(),
+        };
+        Publish(fixture.Publisher, Build(FirstLandblock, [entity]));
+
+        // Sanity: the fix registered a Sphere, not a Cylinder — the dispatch
+        // this test exercises depends on it.
+        ShadowEntry registered = Assert.Single(
+            fixture.Engine.ShadowObjects.AllEntriesForDebug());
+        Assert.Equal(ShadowCollisionType.Sphere, registered.CollisionType);
+
+        var body = MakeGroundedBody(new Vector3(10.7f, 13.05f, 0f));
+        Vector3 target = new(13.3f, 13.05f, 0f);
+
+        ResolveResult result = fixture.Engine.ResolveWithTransition(
+            body.Position, target, 0xA9B40001u,
+            sphereRadius: 0.15f, sphereHeight: 3.0f,
+            stepUpHeight: 0.60f, stepDownHeight: 0.04f,
+            isOnGround: true, body: body,
+            moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide,
+            movingEntityId: 0u);
+
+        Assert.True(
+            MathF.Abs(result.Position.X - target.X) < 0.05f
+                && MathF.Abs(result.Position.Y - target.Y) < 0.05f,
+            "Mover must clear the boulder unobstructed (true-sphere curve-hit "
+            + $"clears at this height/offset); got {result.Position}, wanted {target}.");
+
+        // Review F8 (2026-08-07): the POSITIVE control. Without it, the graze
+        // assertion above also passes when the shadow object is absent from
+        // the queried cell entirely (a membership/seed/flood regression) —
+        // the discriminating power lived only in an unreproducible sabotage
+        // run. Same publication, same cell, but aimed straight THROUGH the
+        // boulder's centre: the head sphere's closest approach to the centre
+        // is (0, 0, 0.85), |d| = 0.85 < radsum 1.15 — the true sphere MUST
+        // block this one. The pair proves reachable AND correctly shaped.
+        var throughBody = MakeGroundedBody(new Vector3(10.7f, 12f, 0f));
+        ResolveResult blockedResult = fixture.Engine.ResolveWithTransition(
+            throughBody.Position, new Vector3(13.3f, 12f, 0f), 0xA9B40001u,
+            sphereRadius: 0.15f, sphereHeight: 3.0f,
+            stepUpHeight: 0.60f, stepDownHeight: 0.04f,
+            isOnGround: true, body: throughBody,
+            moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide,
+            movingEntityId: 0u);
+        Assert.True(
+            MathF.Abs(blockedResult.Position.X - 13.3f) >= 0.05f,
+            "Aiming straight through the boulder's centre must NOT arrive at "
+            + $"the far side; got {blockedResult.Position} — the sphere is "
+            + "either unregistered in cell 0xA9B40001 or not colliding.");
+    }
+
+    private static PhysicsBody MakeGroundedBody(Vector3 position)
+    {
+        var floorPlane = new Plane(Vector3.UnitZ, 0f);
+        var floorVerts = new[]
+        {
+            new Vector3(-100f, -100f, 0f),
+            new Vector3( 100f, -100f, 0f),
+            new Vector3( 100f,  100f, 0f),
+            new Vector3(-100f,  100f, 0f),
+        };
+        return new PhysicsBody
+        {
+            Position             = position,
+            Orientation          = Quaternion.Identity,
+            ContactPlaneValid    = true,
+            ContactPlane         = floorPlane,
+            ContactPlaneCellId   = 0xA9B40001u,
+            WalkablePolygonValid = true,
+            WalkablePlane        = floorPlane,
+            WalkableVertices     = floorVerts,
+            WalkableUp           = Vector3.UnitZ,
+            TransientState       = TransientStateFlags.Contact | TransientStateFlags.OnWalkable,
+        };
+    }
+
     [Fact]
     public void CompletePublication_BuildingShellNeverRegistersSetupCollision()
     {