fix: address PR review findings

- Log CPR-settle failures in `_settle_cursor_after_handoff` via `_handoff_trace`
  + `logger.debug` instead of silently suppressing, matching the sibling
  `_reset_prompt_renderer` / `_safe_prompt_invalidate` handlers (no silent
  swallow).
- Construct `OAuthManager` off the event loop in `refresh_managed_models` via
  `asyncio.to_thread`, so its synchronous `_migrate_oauth_storage()` file lock
  cannot stall async refresh.
- Add a failure-path test asserting the scrollback-handoff `finally` still
  settles the cursor (and the fail path resets the renderer) when emit raises.

Author: elkaix

src/pythinker_code/auth/platforms.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import os
 from typing import Any, NamedTuple, cast
 
@@ -353,7 +354,10 @@ def providers_match(
         if provider.oauth and oauth_manager is None:
             from pythinker_code.auth.oauth import OAuthManager
 
-            oauth_manager = OAuthManager(working_config)
+            # Construct off the event loop: OAuthManager.__init__ can run
+            # _migrate_oauth_storage(), which takes a synchronous cross-process
+            # file lock (5s timeout) and would otherwise stall async refresh.
+            oauth_manager = await asyncio.to_thread(OAuthManager, working_config)
         provider = working_config.providers.get(provider_key)
         if provider is None:
             continue

src/pythinker_code/ui/shell/visualize/_interactive.py

@@ -246,8 +246,11 @@ async def _settle_cursor_after_handoff(self) -> None:
         output = getattr(app, "output", None)
         if output is None or not getattr(output, "responds_to_cpr", False):
             return
-        with suppress(Exception):
+        try:
             await app.renderer.wait_for_cpr_responses()
+        except Exception as exc:  # noqa: BLE001 — settling is best-effort, must not break cleanup
+            _handoff_trace(f"CPR_SETTLE_FAIL\t{type(exc).__name__}:{exc}")
+            logger.debug("CPR settle failed after scrollback handoff: {}", exc)
 
     def _defer_scrollback_handoff(self) -> bool:
         """Backpressure: defer permanent scrollback while preamble geometry is unstable."""

tests/ui_and_conv/test_visualize_running_prompt.py

@@ -272,6 +272,60 @@ async def _settle() -> None:
     assert view._scrollback_handoff_depth == 0
 
 
+@pytest.mark.asyncio
+async def test_scrollback_handoff_settles_cursor_on_failure(monkeypatch) -> None:
+    """When the handoff emit raises, the finally block must still settle the cursor
+    (and the fail path resets the renderer) before the exception propagates — the
+    ordering guarantee that keeps the prompt recoverable after a failed handoff.
+    """
+    from pythinker_code.ui.shell.visualize._blocks import _ContentBlock
+
+    events: list[str] = []
+    depth_at_settle: list[int] = []
+
+    class _PromptSession:
+        def invalidate(self) -> None:
+            return None
+
+    async def _run_in_terminal(func, *args, **kwargs):  # noqa: ANN001, ANN002, ANN003
+        raise RuntimeError("emit failed")
+
+    monkeypatch.setattr(_interactive_mod, "run_in_terminal", _run_in_terminal)
+    monkeypatch.setattr(_live_view_mod.console, "_force_terminal", True)
+    monkeypatch.setattr(
+        _live_view_mod,
+        "emit_scrollback_block",
+        lambda _console, renderable: None,
+    )
+
+    view = _PromptLiveView(
+        StatusUpdate(),
+        prompt_session=cast(Any, _PromptSession()),
+        steer=lambda _content: None,
+    )
+
+    async def _settle() -> None:
+        events.append("settle")
+        depth_at_settle.append(view._scrollback_handoff_depth)
+
+    monkeypatch.setattr(view, "_settle_cursor_after_handoff", _settle)
+    monkeypatch.setattr(
+        view, "_reset_prompt_renderer", lambda reason: events.append(f"reset:{reason}")
+    )
+    block = _ContentBlock(is_think=False)
+    block.append("First paragraph.\n\nMutable tail")
+    assert block._committed_renderables
+    view._current_content_block = block
+
+    with pytest.raises(RuntimeError, match="emit failed"):
+        await view._emit_incremental_content_commits()
+
+    assert "settle" in events, "finally must settle the cursor even when the handoff raises"
+    assert "reset:handoff-fail" in events, "fail path must reset the renderer"
+    assert depth_at_settle == [1], "cursor settles while the handoff is still suppressed"
+    assert view._scrollback_handoff_depth == 0
+
+
 def test_status_loop_has_no_midstream_commit_throttle() -> None:
     """Regression guard: the per-tick mid-stream commit (the source of the
     run_in_terminal "jump") must not come back. Completed prose stays in the