test(connect): phase 5 — restart lands on the selected profile, no login (#827)

* test(connect): pin restart-with-scoped-profile token resolution (phase 5)

* fix(profiles): scope switch via un-clamped active-profile state

The switch persisted the server profile through serverStore.selectedProfileId,
whose selfHealed() clamps ids absent from the local connection list — server
profiles like "meow" never exist there, so the scope silently reset to
default and the re-dialed socket created the fresh session in the wrong
profile (live logcat 2026-08-06: session.create carried profile=default
right after switching to meow).

- AuthManager: prefs-backed activeProfileId state, immune to the clamp,
  restored on startup; resetAuthStateForTest clears it
- ProfileScopeInterceptor + WsProfileParams + ChatViewModel fetchContextUsage:
  read the active profile instead of the connection selection
- ProfileSwitchCoordinator: write activeProfileId; dial the socket on
  Dispatchers.IO (the ticket mint did blocking I/O on the main thread —
  NetworkOnMainThreadException — and fell back to a 1s reconnect)
- ProfilesViewModel: inject the IO dispatcher; ProfilesViewModelTest drops
  its static Dispatchers mock (JVM-wide bleed class)
- Tests: WsProfileParams/Interceptor tests use the real prefs-backed state
  instead of mockkObject(AuthManager) (re-mock breaks in suite order after
  real AuthManager init); AuthManagerTest + Issue647ProfileUrlTest cancel
  the init() DataStore scope in tearDown (UncaughtExceptionsBeforeTest
  phantoms); regression test pins the clamp on the old path vs the new state

* fix(profiles): resolve getter/property JVM collision; de-poison slash test

- AuthManager.activeProfileId (StateFlow) and a getActiveProfileId()
  function generated the same JVM getter name — calls silently resolved to
  the property getter at runtime (ReadonlyStateFlow -> String
  ClassCastException, CI unit red 2026-08-06). Function removed; callers
  read activeProfileId.value.
- ChatViewModel: inject ioDispatcher (38 sites) so SlashCommandDispatchRpcTest
  can drop its mockkStatic(Dispatchers) bleed without racing real IO.
- SlashCommandDispatchRpcTest: drop the static Dispatchers mock (JVM-wide
  bleed; CI cross-wired COMMAND_DISPATCH captures in suite order), construct
  the VM with the test dispatcher.

---------

Co-authored-by: M57 <hy4ri@users.noreply.github.com>

app/src/main/java/com/m57/hermescontrol/data/local/AuthManager.kt

@@ -41,6 +41,7 @@ import kotlinx.coroutines.runBlocking
  */
 object AuthManager {
     private const val PREFS_FILE = "hermes_secure_prefs"
+    private const val KEY_ACTIVE_PROFILE_ID = "active_profile_id"
 
     const val DEFAULT_PROFILE_ID = "default"
     const val DEFAULT_PROFILE_NAME = "Default"
@@ -80,6 +81,21 @@ object AuthManager {
     private val _selectedProfileFlow = MutableStateFlow<String?>(null)
     val selectedProfileFlow: StateFlow<String?> = _selectedProfileFlow.asStateFlow()
 
+    /**
+     * Active server-side Hermes profile scope (e.g. "default" / "meow").
+     *
+     * DISTINCT from [selectedProfileId] (which selects a LOCAL connection
+     * profile — a server + its token). The active profile is the scope
+     * injected as REST `?profile=` and WS `params.profile`. It deliberately
+     * does NOT route through [ServerStoreState.selfHealed]: server profile
+     * ids are not guaranteed to exist in the local connection list, and
+     * clamping them silently reset the scope to "default" — the live
+     * profile-switch bug (logcat 2026-08-06: session.create carried
+     * profile=default right after switching to meow).
+     */
+    private val _activeProfileId = MutableStateFlow<String?>(null)
+    val activeProfileId: StateFlow<String?> = _activeProfileId.asStateFlow()
+
     private val _baseUrlFlow = MutableStateFlow("")
     val baseUrlFlow: StateFlow<String> = _baseUrlFlow.asStateFlow()
 
@@ -146,6 +162,7 @@ object AuthManager {
                             )
                         migrateLegacyDefaultIfNeeded(p)
                         _tokenFlow.value = getTokenInternal(p)
+                        _activeProfileId.value = p.getString(KEY_ACTIVE_PROFILE_ID, null)?.takeIf { it.isNotBlank() }
                         p
                     }
             }
@@ -374,6 +391,28 @@ object AuthManager {
         appScope?.launch { syncCookieStoreForProfile(id) }
     }
 
+    /**
+     * Set the active server-side Hermes profile scope.
+     *
+     * Unlike [setSelectedProfileId], this does NOT touch the server store —
+     * it is prefs-backed and immune to [ServerStoreState.selfHealed], so a
+     * server profile that has no local [ConnectionProfile] (the normal case)
+     * survives the switch instead of being clamped to null/default.
+     *
+     * NOTE: read the value via [activeProfileId].value — a JVM getter named
+     * `getActiveProfileId()` would collide with the property's generated
+     * getter (same name, different return type) and silently resolve to the
+     * property getter at runtime (ClassCastException: ReadonlyStateFlow ->
+     * String, 2026-08-06 CI).
+     */
+    fun setActiveProfileId(id: String?) {
+        val normalized = id?.takeIf { it.isNotBlank() }
+        _activeProfileId.value = normalized
+        runCatching {
+            requirePrefs().edit().putString(KEY_ACTIVE_PROFILE_ID, normalized).apply()
+        }
+    }
+
     private fun normalizedProfileId(profileId: String?): String =
         profileId?.takeIf { it.isNotBlank() } ?: DEFAULT_PROFILE_ID
 
@@ -416,6 +455,7 @@ object AuthManager {
             }
             appScope = null
         }
+        _activeProfileId.value = null
     }
 
     fun getToken(): String? {

app/src/main/java/com/m57/hermescontrol/data/remote/ProfileScopeInterceptor.kt

@@ -60,7 +60,7 @@ object ProfileScopeInterceptor : Interceptor {
     override fun intercept(chain: Interceptor.Chain): Response {
         val request = chain.request()
         val profile =
-            AuthManager.getSelectedProfileId()
+            AuthManager.activeProfileId.value
                 ?: return chain.proceed(request)
 
         val url = request.url

app/src/main/java/com/m57/hermescontrol/data/session/ProfileSwitchCoordinator.kt

@@ -41,10 +41,16 @@ object ProfileSwitchCoordinator {
             }
         if (result !is NetworkResult.Success) return result
 
-        AuthManager.setSelectedProfileId(name)
+        AuthManager.setActiveProfileId(name)
         _switched.emit(name)
-        HermesWsClient.disconnect()
-        HermesWsClient.connect()
+        // The ticket mint inside connect() does blocking network I/O — it must
+        // run off the main thread or the dial crashes with
+        // NetworkOnMainThreadException and falls back to the 1s reconnect
+        // retry (visible in the 2026-08-06 live logcat).
+        withContext(Dispatchers.IO) {
+            HermesWsClient.disconnect()
+            HermesWsClient.connect()
+        }
         return result
     }
 }

app/src/main/java/com/m57/hermescontrol/data/ws/WsProfileParams.kt

@@ -11,7 +11,7 @@ import com.m57.hermescontrol.data.local.AuthManager
  * (usually "default"), even after the user switches profiles in the app.
  *
  * Rules (mirror the REST interceptor contract):
- *  - If [AuthManager.getSelectedProfileId] is `null` → pass through unchanged
+ *  - If [AuthManager.activeProfileId] is `null` → pass through unchanged
  *    (legacy single-profile behavior).
  *  - If the caller already supplied an explicit `"profile"` key in [params] →
  *    explicit wins; do **not** overwrite.
@@ -29,7 +29,7 @@ object WsProfileParams {
         params: Map<String, Any>,
     ): Map<String, Any> {
         // No active profile → legacy single-profile behavior.
-        val profile = AuthManager.getSelectedProfileId() ?: return params
+        val profile = AuthManager.activeProfileId.value ?: return params
 
         // Only scoped methods get the profile key.
         if (method !in WsMethods.PROFILE_SCOPED_METHODS) return params