feat(sessions): empty-session cleanup + latest-descendant resume + fresh-session 404 fix (#787, #840) (#841)

* feat(sessions): empty-session cleanup button + latest-descendant resume + fresh-session 404 fix (issues #787, #840)

- Sessions top bar: Delete-empty icon with count badge, grey/disabled when 0
  (GET /api/sessions/empty/count + DELETE /api/sessions/empty, confirm dialog)
- Resume flow resolves GET /api/sessions/{id}/latest-descendant first —
  branched sessions continue in the newest child leaf, not the stale parent
  (best-effort; falls back to the requested id)
- syncCurrentSession guarded by sessionHasServerPresence — a freshly created
  (never prompted) session has no server row yet; the REST transcript 404s
  and the resume retry spun forever (logcat 404 evidence)

* fix(sessions): clamp message-count fallback to backend limit cap (422)

fetchServerMessageCount requested limit=500 but the backend caps
session list page size at 100 (sessions.py Query le=100) — every
fallback scan 422'd (seen in device logcat after a branch). Sessions
are ordered recent, so the target is always in the top page.

* test(slash): make dispatch-capture assertions order-independent (CI flake)

The capture-race flake (SlashCommandDispatchRpcTest, hit 3x across CI and
local runs 2026-08-07): tests asserted on methodSlot.captured — the LAST
request captured — but the create flow's session.usage/context_breakdown
requests can land after the slash-dispatch one depending on suite order
(the class's own comment documents this cross-wiring). Converted the
three capture-based tests to capture ALL requests and find the target
record by method, with dispatch-before-fallback ordering for the 4018
test. Same assertions, no dependence on request interleaving.

* test(slash): convert remaining capture-race assertions (flake round 2)

The capture race moved to the focus/init tests (:424) after the first
three were fixed — every request-capture test in the class used the
same last-captured assumption. Converted the remaining five (init,
init+arg, focus, focus on, type=send) to the find-record-by-method
pattern; the type=send answers block reads methodCalls.last() since the
capture precedes the answer. Zero request() slot captures remain.

* test(slash): blocklist assertion counts command RPCs only (flake round 3)

The blocklisted-command test counted ALL request() calls and asserted
zero — the create flow's session.usage/context_breakdown noise can land
in the window after the stub registers (the same capture race that hit
the dispatch tests). Asserted instead that no COMMAND_DISPATCH or
SLASH_EXEC fires, which is the actual blocklist contract. E2E's static
Dispatchers mock stays (E2E VMs need IO routed to the test dispatcher —
removing it broke 20 E2E tests).

---------

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

app/src/main/java/com/m57/hermescontrol/ui/chat/ChatViewModel.kt

@@ -1761,17 +1761,46 @@ class ChatViewModel(
         val title = _uiState.value.sessions.find { it.id == sessionId }?.title ?: "Hermes"
         val generation = resetSessionState(sessionId, title, isLoading = true)
         viewModelScope.launch {
+            // Desktop parity (issue #787): a branched session's "current" row
+            // is its newest child leaf (/model, /branch) — resume THAT instead
+            // of the stale parent. Best-effort: on any failure (404 for a
+            // missing session, network blip) fall back to the requested id.
+            val effectiveId = resolveLatestDescendant(sessionId) ?: sessionId
+            val effectiveGeneration =
+                if (effectiveId != sessionId) {
+                    resetSessionState(effectiveId, title, isLoading = true)
+                } else {
+                    generation
+                }
             // Warm-cache fast-path (desktop parity): paint the cached Room
             // transcript immediately so the screen never sits blank, then load
             // the fresh server transcript in parallel. If the cache is empty
             // the spinner stays up until the server page lands.
-            loadCachedMessages(sessionId, generation)
+            loadCachedMessages(effectiveId, effectiveGeneration)
             // Resume the selected desktop session and hydrate its transcript.
-            resumeSession(sessionId, generation)
+            resumeSession(effectiveId, effectiveGeneration)
             loadSessions()
         }
     }
 
+    /**
+     * Resolve the newest descendant of a session (issue #787, desktop parity).
+     * A branched session continues in a child leaf; resuming the parent would
+     * open a stale branch. Returns null on any failure (sessions without
+     * descendants report `changed=false`; missing sessions 404) so callers
+     * fall back to the requested id.
+     */
+    private suspend fun resolveLatestDescendant(sessionId: String): String? =
+        withContext(ioDispatcher) {
+            val result =
+                runCatching {
+                    safeApiCall { ApiClient.hermesApi.getLatestDescendant(sessionId) }
+                }.getOrNull()
+            (result as? NetworkResult.Success)?.data
+                ?.takeIf { it.changed }
+                ?.session_id
+        }
+
     private fun loadCachedMessages(
         sessionId: String,
         generation: Long,
@@ -2144,6 +2173,11 @@ class ChatViewModel(
     }
 
     fun syncCurrentSession() {
+        // Issue #840: a session created but never prompted has no server row
+        // yet — the REST transcript 404s and the resume-retry machinery spins
+        // forever (visible in logcat as repeated /messages 404s). MessageStart
+        // flips the flag once the first prompt persists the row.
+        if (!sessionHasServerPresence) return
         val state = _uiState.value
         val sessionId = state.currentSessionId ?: return
         val generation = sessionGeneration
@@ -2367,7 +2401,10 @@ class ChatViewModel(
         if (known != null) return known
         val result =
             withContext(ioDispatcher) {
-                safeApiCall { ApiClient.hermesApi.getSessions(limit = 500, offset = 0, order = "recent") }
+                // Backend caps limit at 100 (sessions.py Query le=100) — 500
+                // 422'd (seen in device logcat after a branch). Sessions are
+                // ordered "recent", so the target is always in the top page.
+                safeApiCall { ApiClient.hermesApi.getSessions(limit = 100, offset = 0, order = "recent") }
             }
         if (result is NetworkResult.Success) {
             val sessions = result.data.sessions.orEmpty()