feat(runtime): C3c - production placement cutover: both hosts on the residence conductors (routes 1+8)

Campaign P remaining-physics-divergence, placement cutover slice C3c
(docs/plans/2026-08-02-placement-cutover.md). Both production hosts now
register every initial Create through the residence + continuation-
executor + first-entry-conductor machinery (C0-C3b):

- Graphical (route 1): RegisterEntityWithInitialResidence at Create; the
  shared RuntimeFirstEntryDriveController pumps both conductors from the
  placement-receipt flow; MaterializeProjection and RebucketLiveEntity
  are presentation-only while a residence is ACTIVE (ExecutorCompleted is
  the presentation-binding receipt); post-residence entities take the
  full legacy path including the prepare_to_enter_world clock edges.
  PlayerModeController attaches presentation to the Runtime-published
  controller; its legacy resolve/step-heights/host-construction path is
  deleted; presentation-only rollback (retail has no entry-flow rollback).
- Headless (route 8): OnSpawned registers with residence when a drive
  exists; content-less sessions keep the pre-flip direct registration;
  SynchronizeLocalPlayer/CreateController/ApplySetupStepHeights deleted;
  prepared-collision read failure is a typed AwaitingCollisionSource
  retry; far remotes outside the service window complete celless.
- RuntimeLocalPlayerMovementState.Controller setter sealed internal; all
  controller mutation flows through the publication lifecycle.

Fix slices landed within this cutover, each dual-gated:
- F1: live movement-stat/server-physics application routed through the
  Runtime ownership seam (post-logout ingest crash on the retired
  controller eliminated; RuntimeMovementSkillProjection deleted).
- F2: login activation wedge - collision-admission prefix gate factored
  out of the seal (reentrant-commit RejectedAuthority), rearm generation
  identity corrected, PlayerModeAutoEntry requires the Runtime-published
  controller (world reveal can no longer seal unmaterialized).
- F3: landblock-prefix 0-sentinel replaced by explicit absent-id guards;
  map-corner landblocks (grid row/col 0) fully legal through admission,
  park/rearm/retire, quiescence, and outdoor shadow seeds.
- F5: local-player first-entry ground contact seeded by the shared
  SpawnPlacementSettler (moved App->Core) at FinalizeActivation - the
  retail first-gravity-frame touch (enter_world 0x00516170 carries no
  seed); the legacy unconditional force-seed is overwritten by a real
  floor-found contact; airborne spawns stay airborne; outbound contact
  bit verified end-to-end. Fixes the standing-cast 'You can't do that
  while in the air!' rejections.
- R1 (dual-review round): login constraint leash armed at the committed
  placement (HandleReceivedPosition 0x00453FD0 analog); register rows
  AD-61 (settle-timing compression now covering the local player) and
  AD-42 (repointed off the deleted resolve split) in this commit;
  residence-conversion owner API; wire-landblock guards; drive-pending
  ledger in IsConverged; route attach/detach latch; executor-drain drift
  model documented + source-pinned.

Gates: Runtime 1,003, App 4,039/3 skips, Headless 79, complete solution
10,816/0 failed/4 skips (Release, -m:1); connected lifecycle/reconnect
gate PASS (logs/connected-world-gate-20260802-175401; graceful exits,
world-visible, zero airborne rejections). The nine-stop soak remains red
for the pre-existing 6b28ff99 whole-world collision-clone throughput
regression (attributed with evidence; scheduled as its own slice before
C5). Dual Opus reviews (retail-conformance + adversarial): delta PASS.

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

tests/AcDream.App.Tests/Net/LiveMovementStatsApplierTests.cs

@@ -0,0 +1,204 @@
+using System.Net;
+using AcDream.App.Net;
+using AcDream.Core.Chat;
+using AcDream.Core.Combat;
+using AcDream.Core.Items;
+using AcDream.Core.Net;
+using AcDream.Core.Physics;
+using AcDream.Core.Social;
+using AcDream.Runtime.Gameplay;
+using AcDream.Runtime.Session;
+
+namespace AcDream.App.Tests.Net;
+
+/// <summary>
+/// C3c-F1 (2026-08-02): the movement-stats application seam driven through
+/// the REAL inbound chain that crashed the connected lifecycle gate —
+/// <c>ClientObjectTable.Ingest</c> → <c>ObjectAdded/ObjectUpdated</c> →
+/// <c>LiveSessionEventRouter.RecomputePlayerQualities</c> →
+/// <c>OnMovementStatsUpdated</c> → <see cref="LiveMovementStatsApplier"/> →
+/// <see cref="RuntimeLocalPlayerMovementState.ApplyCharacterMovementStats"/>.
+/// </summary>
+public sealed class LiveMovementStatsApplierTests
+{
+    private const uint PlayerGuid = 0x5000000Au;
+
+    private sealed class Harness : IDisposable
+    {
+        public WorldSession Session { get; }
+        public LiveSessionEventRouter Router { get; }
+        public ClientObjectTable Objects { get; } = new();
+        public RuntimeCharacterState Character { get; } = new();
+        public RuntimeLocalPlayerMovementState Movement { get; } = new();
+        public LiveMovementStatsApplier Applier { get; }
+        public List<string> Log { get; } = [];
+
+        public Harness()
+        {
+            Session = new WorldSession(new IPEndPoint(IPAddress.Loopback, 9));
+            // The REAL applier the factory binds (LiveSessionRuntimeFactory
+            // constructs the same class over the same owner pair) with the
+            // REAL character-bindings recompute callback shape.
+            Applier = new LiveMovementStatsApplier(
+                Movement,
+                Character.MovementSkills,
+                Log.Add);
+            Router = new LiveSessionEventRouter(
+                Session,
+                new LiveEntitySessionSink(
+                    _ => { }, _ => { }, _ => { }, _ => { }, _ => { }, _ => { },
+                    _ => { }, _ => { }, _ => { }, _ => { }, _ => { }, _ => { }),
+                new LiveEnvironmentSessionSink(_ => { }, _ => { }),
+                new LiveInventorySessionBindings(
+                    Objects,
+                    PlayerGuid: () => PlayerGuid,
+                    OnShortcuts: null,
+                    OnUseDone: null,
+                    ItemMana: new ItemManaState(),
+                    ExternalContainers: new ExternalContainerState()),
+                new LiveCharacterSessionBindings(
+                    new CombatState(),
+                    Character,
+                    ResolveSkillFormulaBonus: null,
+                    OnSkillsUpdated: (_, _) => Applier.Apply("skills"),
+                    OnConfirmationRequest: null,
+                    OnConfirmationDone: null,
+                    ClientTime: () => 0d,
+                    OnMovementStatsUpdated: () => Applier.Apply("stats")),
+                new LiveSocialSessionBindings(
+                    new ChatLog(),
+                    new TurbineChatState(),
+                    new FriendsState(),
+                    new SquelchState()));
+            Router.Attach();
+        }
+
+        /// <summary>
+        /// Ingests the player's own object row — the exact post-logout
+        /// inbound-Create edge (<c>ApplyAcceptedSpawn</c> →
+        /// <c>ClientObjectTable.Ingest</c>) that fired the crashing
+        /// recompute in logs/connected-world-gate-20260802-122749.
+        /// </summary>
+        public void IngestPlayerRow(uint? pwdBitfield = null) =>
+            Objects.Ingest(new WeenieData(
+                Guid: PlayerGuid, Name: "+Acdream", Type: ItemType.Creature,
+                WeenieClassId: 1u, IconId: 0, IconOverlayId: 0,
+                IconUnderlayId: 0, Effects: 0,
+                Value: null, StackSize: null, StackSizeMax: null, Burden: null,
+                ContainerId: null, WielderId: null, ValidLocations: null,
+                CurrentWieldedLocation: null, Priority: null,
+                ItemsCapacity: null, ContainersCapacity: null,
+                Structure: null, MaxStructure: null, Workmanship: null,
+                PublicWeenieBitfield: pwdBitfield));
+
+        public void Dispose()
+        {
+            Router.Dispose();
+            Session.Dispose();
+            Movement.Dispose();
+            Character.Dispose();
+        }
+    }
+
+    private static PlayerMovementController NewDormantRuntimeController()
+    {
+        PlayerMovementController controller =
+            PlayerMovementController.CreatePublicationCandidate(
+                new PhysicsEngine(),
+                PlayerMovementConstructionOptions.Fallback);
+        controller.SealPublicationCandidate();
+        controller.CommitRuntimeOwnership(new RetailObjectQuantumClock());
+        return controller;
+    }
+
+    [Fact]
+    public void PostTeardownIngestRecomputeReportsTypedDropInsteadOfCrashing()
+    {
+        using var harness = new Harness();
+        // The session's authoritative skills were complete before teardown.
+        harness.Character.MovementSkills.Update(runSkill: 240, jumpSkill: 180);
+
+        // Post-teardown transient truth: a retired controller still
+        // reachable through the displaced recompute callback — the state the
+        // old direct path crashed on ("A sealed, retired, or discarded
+        // Runtime movement controller cannot be mutated").
+        PlayerMovementController controller = NewDormantRuntimeController();
+        harness.Movement.Controller = controller;
+        controller.ActivateRuntimePublication();
+        controller.RetireRuntimePublication();
+        Assert.Throws<InvalidOperationException>(
+            () => controller.SetCharacterSkills(1, 1));
+
+        // The exact crash edge: a post-logout inbound Create's object-table
+        // ingest fires the quality recompute through the real router.
+        harness.IngestPlayerRow();
+
+        Assert.Contains(
+            harness.Log,
+            line => line.StartsWith(
+                "player: dropped displaced movement stats",
+                StringComparison.Ordinal));
+        Assert.DoesNotContain(
+            harness.Log,
+            line => line.StartsWith(
+                "player: applied server movement",
+                StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void DormantWindowIngestRecomputeAppliesToTheControllerThatGoesLive()
+    {
+        using var harness = new Harness();
+        harness.Character.MovementSkills.Update(runSkill: 240, jumpSkill: 180);
+        harness.Character.MovementSkills.UpdateStamina(37);
+
+        // The committed-but-unactivated first-entry window (activation
+        // deferred on cell streaming) with inbound ingests still pumping.
+        PlayerMovementController controller = NewDormantRuntimeController();
+        harness.Movement.Controller = controller;
+        Assert.True(controller.IsRuntimeOwnedDormant);
+
+        // BF_PLAYER (0x8) + BF_PLAYER_KILLER (0x20) on the player's own row
+        // exercises the full stat set through the recompute.
+        harness.IngestPlayerRow(pwdBitfield: 0x28u);
+
+        Assert.Contains(
+            harness.Log,
+            line => line.StartsWith(
+                "player: applied server movement stats",
+                StringComparison.Ordinal));
+
+        // The same instance goes live at activation with the values already
+        // current.
+        controller.ActivateRuntimePublication();
+        IWeenieObject weenie = controller.Motion.WeenieObj!;
+        Assert.True(weenie.InqRunRate(out float runRate));
+        Assert.True(runRate > 0f);
+        Assert.Equal(
+            ObjectInfoState.IsPK,
+            controller.OwnPvpFlags & ObjectInfoState.IsPK);
+    }
+
+    [Fact]
+    public void AbsentControllerAndIncompleteSnapshotStaySilent()
+    {
+        using var harness = new Harness();
+
+        // Incomplete snapshot (no PlayerDescription yet) with no controller:
+        // byte-identical to the pre-F1 silent skip — no log line at all.
+        harness.IngestPlayerRow();
+        Assert.DoesNotContain(
+            harness.Log,
+            line => line.StartsWith("player:", StringComparison.Ordinal));
+
+        // Complete snapshot but still no controller (pre-first-entry):
+        // still the silent skip.
+        harness.Character.MovementSkills.Update(runSkill: 240, jumpSkill: 180);
+        Assert.Equal(
+            RuntimeMovementStatsApplication.DroppedNoController,
+            harness.Applier.Apply("stats"));
+        Assert.DoesNotContain(
+            harness.Log,
+            line => line.StartsWith("player:", StringComparison.Ordinal));
+    }
+}

tests/AcDream.App.Tests/Net/LiveSessionResetPlanTests.cs

@@ -257,7 +257,12 @@ public sealed class LiveSessionResetPlanTests
             spatial,
             new FailingOnceResources(),
             runtime.EntityObjects);
-        live.RegisterLiveEntity(Spawn(player, 1, 1, 0x01010001u));
+        // C3c: this GameRuntime has no session, so its generation is zero and
+        // residence-based registration (RegisterLiveEntity) correctly refuses
+        // an initial world Create. The subject here is reset/teardown retry,
+        // not the create flow — seed the entity through the legacy direct
+        // Runtime registration, which needs no residence lease.
+        runtime.EntityObjects.RegisterEntity(Spawn(player, 1, 1, 0x01010001u));
         live.MaterializeLiveEntity(
             player,
             0x01010001u,