fix #414: cursor disappears at character select after the in-world logoff

Session teardown (PlayerModeController.Exit/ResetSession ->
CameraController.ExitChaseMode) fell back to the dev free-fly camera, and
CameraPointerInputController.ApplyCursorForCameraMode faithfully applies
CursorMode.Raw (GLFW disabled cursor: hidden + captured) for fly mode —
so the character-select screen after an in-world logoff had no mouse.
Fresh boot starts in Orbit and never fires a mode change, which is why
only the post-logout path was affected.

Teardown now lands on Mode.Orbit — the exact state a fresh boot presents
at character select — and always notifies, so the pointer controller
restores CursorMode.Normal even when torn down from the dev fly camera.
The dev fly<->chase flow is untouched (it rides ToggleFly, never
ExitChaseMode).

Proven live both directions with a driven logout (UI probe 0x100000FA ->
dialog accept 0x17) under Win32 GetCursorInfo sampling: before, flags
flipped 1->0 exactly at the roster re-push that re-shows character select
and stayed hidden; after, zero hidden samples across the full timeline.
Files #415: the UI-probe 'wait world-visible' verb reads the reset
transit snapshot and is dead after reveal completion (test apparatus
only).

App tests 5564/3 skips (+3), Runtime 1756/0.

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

docs/ISSUES.md

@@ -24,6 +24,48 @@ What does NOT go here:
 - Every session: scan OPEN issues at start; promote/close anything we touched during the session before ending.
 - Promoting to a Phase: mark as `DONE (promoted to Phase X)` + commit SHA where the Phase entry landed.
 
+## #415 — UI-probe `wait world-visible` verb is dead after reveal completion (automation bridge reads the reset snapshot)
+
+**Status:** OPEN (filed 2026-08-17 at the #414 cursor repro). The script
+runner's `wait world-visible` polls
+`WorldLifecycleAutomationController.IsWorldViewportVisible`, which reads
+`_getReveal().WorldViewportObserved` from the LIVE transit snapshot. The
+reveal's `event=complete` retires that generation and the snapshot resets
+`WorldViewportObserved: false` (`RuntimeWorldTransitState.cs:583`), so the
+verb only observes true during the sub-second window between
+`event=world-visible` and `event=complete` — in practice it times out even
+though the world revealed (proved by the #414 repro logs: `wait
+world-visible 60000` timed out with `event=world-visible` present in the
+same run's `[world-reveal]` stream). Fix shape: the automation controller
+should latch world-visible per generation (or the verb should accept
+`IsWorldReady`-style completed state), not read the transient snapshot.
+Test apparatus only — no player impact.
+
+## #414 — Mouse cursor disappears at character select after the in-world logoff (teardown fly-mode fallback raw-captures the cursor)
+
+**Status:** ✅ FIXED 2026-08-17 (entry/exit presentation follow-up; fix +
+regression tests in the same commit as this entry). **Symptom:** press the
+indicator bar's X, confirm Yes, land on character select — the OS cursor is
+gone (and captured). Second Enter still works; the cursor returns once a
+world login re-enters chase mode. **Evidence:** live Win32 `GetCursorInfo`
+sampling over the driven logout (scripted UI probe: `0x100000FA` → dialog
+accept `0x17`) — cursor flags flipped `1 → 0` (hCursor `0x0`) exactly at
+the roster re-push that re-shows character select, and stayed hidden.
+**Root cause:** `CameraController.ExitChaseMode` (called from
+`PlayerModeController.Exit`/`ResetSession` at every session teardown) fell
+back to `Mode.Fly` — the pre-retail dev free-camera convention — and
+`CameraPointerInputController.ApplyCursorForCameraMode` faithfully applies
+`CursorMode.Raw` (GLFW disabled cursor: hidden + captured) for fly mode.
+Fresh boot never fires a mode change at character select (starts Orbit), so
+only the post-logout path was affected. **Fix:** teardown lands on
+`Mode.Orbit` — the exact state a fresh boot presents at character select —
+and always notifies, so the pointer controller restores `CursorMode.Normal`
+even when torn down from the dev fly camera. The dev fly↔chase flow is
+untouched (it rides `ToggleFly`, never `ExitChaseMode`).
+`CameraControllerTests`: chase→orbit + notify, fly→orbit + notify,
+orbit no-op no-notify; the old fly-fallback assertion updated to the new
+contract.
+
 ## #413 — House tab shows no content (owned-house display, Display* line builders unported)
 
 **Status:** NARROWED 2026-08-17 (House-tab ownership-text closer session);

src/AcDream.App/Rendering/CameraController.cs

@@ -87,16 +87,24 @@ public sealed class CameraController
         ModeChanged?.Invoke(IsChaseMode);
     }
 
+    /// <summary>
+    /// Player-mode teardown (logout, session reset). Lands on the neutral
+    /// orbit camera — the same state a fresh boot presents at character
+    /// select — NOT the dev free-fly camera: fly mode raw-captures the OS
+    /// cursor (<c>CameraPointerInputController.ApplyCursorForCameraMode</c>
+    /// sets <c>CursorMode.Raw</c>), and the old <c>Mode.Fly</c> fallback
+    /// left the character-select screen after an in-world logoff with a
+    /// hidden, captured mouse. The dev fly↔chase flow is unaffected — it
+    /// rides <see cref="ToggleFly"/>, never this teardown path.
+    /// </summary>
     public void ExitChaseMode()
     {
-        bool wasChaseMode = IsChaseMode;
         Chase       = null;
         RetailChase = null;
         if (_mode == Mode.Orbit)
             return;
-        _mode       = Mode.Fly;
-        if (wasChaseMode)
-            ModeChanged?.Invoke(IsFlyMode);
+        _mode       = Mode.Orbit;
+        ModeChanged?.Invoke(false);
     }
 
     public void SetAspect(float aspect)

tests/AcDream.App.Tests/Rendering/CameraControllerTests.cs

@@ -118,11 +118,58 @@ public class CameraControllerTests
 
         ctl.ExitChaseMode();
 
-        Assert.True(ctl.IsFlyMode);
+        // Teardown lands on orbit even from the dev fly camera: fly mode
+        // raw-captures the OS cursor, and a session teardown must leave the
+        // character-select screen with a normal visible pointer.
+        Assert.False(ctl.IsFlyMode);
+        Assert.False(ctl.IsChaseMode);
         Assert.Null(ctl.Chase);
         Assert.Null(ctl.RetailChase);
     }
 
+    [Fact]
+    public void ExitChaseMode_FromChaseLandsOnOrbitAndNotifies()
+    {
+        var (ctl, _, _) = MakeChaseFixture();
+        int notifications = 0;
+        bool? lastArg = null;
+        ctl.ModeChanged += arg => { notifications++; lastArg = arg; };
+
+        ctl.ExitChaseMode();
+
+        Assert.False(ctl.IsChaseMode);
+        Assert.False(ctl.IsFlyMode);
+        Assert.Equal(1, notifications);
+        Assert.False(lastArg);
+    }
+
+    [Fact]
+    public void ExitChaseMode_FromFlyNotifiesSoCursorCaptureReleases()
+    {
+        var ctl = new CameraController(new OrbitCamera(), new FlyCamera());
+        ctl.ToggleFly();
+        Assert.True(ctl.IsFlyMode);
+        int notifications = 0;
+        ctl.ModeChanged += _ => notifications++;
+
+        ctl.ExitChaseMode();
+
+        Assert.False(ctl.IsFlyMode);
+        Assert.Equal(1, notifications);
+    }
+
+    [Fact]
+    public void ExitChaseMode_FromOrbitDoesNotNotify()
+    {
+        var ctl = new CameraController(new OrbitCamera(), new FlyCamera());
+        int notifications = 0;
+        ctl.ModeChanged += _ => notifications++;
+
+        ctl.ExitChaseMode();
+
+        Assert.Equal(0, notifications);
+    }
+
     [Fact]
     public void RestoreState_ReestablishesPriorCameraAfterNotificationFailure()
     {