Fix stale sessions in admin dashboard and improve auto-routing health

- Add session cleanup background task (runs every 60s) to remove inactive sessions
- Wire cleanup loop into AppRuntime startup/shutdown lifecycle
- Per-provider health parameters: NIM gets tighter TTL (15s/2 failures), Zen looser (60s/5)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

api/runtime.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
@@ -104,6 +105,7 @@ class AppRuntime:
     messaging_platform: MessagingPlatform | None = None
     message_handler: ClaudeMessageHandler | None = None
     cli_manager: CLISessionManager | None = None
+    _session_cleanup_task: asyncio.Task | None = field(default=None, init=False)
 
     @classmethod
     def for_app(
@@ -135,6 +137,12 @@ class AppRuntime:
             # Pre-warm provider connections on startup for faster first request
             await self._warmup_providers()
             await self._start_messaging_if_configured()
+            # Start background session cleanup
+            from core.session_tracker import SessionTracker
+
+            self._session_cleanup_task = asyncio.create_task(
+                SessionTracker.get_instance().start_cleanup_loop()
+            )
             self._publish_state()
         except Exception as exc:
             log_startup_failure(self.settings, exc)
@@ -147,6 +155,11 @@ class AppRuntime:
 
     async def shutdown(self) -> None:
         verbose = self.settings.log_api_error_tracebacks
+        # Cancel session cleanup task
+        if self._session_cleanup_task is not None:
+            self._session_cleanup_task.cancel()
+            with suppress(asyncio.CancelledError, asyncio.TimeoutError):
+                await asyncio.wait_for(self._session_cleanup_task, timeout=2.0)
         if self.message_handler is not None:
             try:
                 self.message_handler.session_store.flush_pending_save()

core/session_tracker.py

@@ -91,7 +91,7 @@ class SessionTracker:
         cls._instance = None
 
     def _cleanup_old_sessions(self) -> None:
-        """Remove sessions with no recent activity."""
+        """Remove sessions with no recent activity (must be called with lock held)."""
         now = time.monotonic()
         cutoff = now - (self._window_seconds * 2)
         to_remove = [
@@ -103,6 +103,19 @@ class SessionTracker:
             del self._sessions[sid]
             if sid in self._session_requests:
                 del self._session_requests[sid]
+        if to_remove:
+            logger.debug(
+                "SessionTracker: cleaned up {} stale sessions ({} remaining)",
+                len(to_remove),
+                len(self._sessions),
+            )
+
+    async def start_cleanup_loop(self, interval: float = 60.0) -> None:
+        """Background task: periodically clean up stale sessions."""
+        while True:
+            await asyncio.sleep(interval)
+            async with self._lock:
+                self._cleanup_old_sessions()
 
     def _evict_lru_session(self) -> None:
         """Evict least recently used session when at capacity."""

providers/rate_limit.py

@@ -21,10 +21,25 @@ class ModelHealthTracker:
 
     _instance: ClassVar[ModelHealthTracker | None] = None
 
-    def __init__(self, failure_ttl: float = 30.0, max_failures: int = 3) -> None:
+    def __init__(
+        self,
+        failure_ttl: float = 30.0,
+        max_failures: int = 3,
+        *,
+        failure_ttl_nim: float = 15.0,
+        max_failures_nim: int = 2,
+        failure_ttl_zen: float = 60.0,
+        max_failures_zen: int = 5,
+    ) -> None:
         self._failure_ttl = failure_ttl
         self._max_failures = max_failures
+        self._failure_ttl_nim = failure_ttl_nim
+        self._max_failures_nim = max_failures_nim
+        self._failure_ttl_zen = failure_ttl_zen
+        self._max_failures_zen = max_failures_zen
         self._failures: dict[str, list[float]] = {}
+        self._failure_ttls: dict[str, float] = {}
+        self._max_failures_map: dict[str, int] = {}
 
     @classmethod
     def get_instance(cls) -> ModelHealthTracker:
@@ -32,6 +47,16 @@ class ModelHealthTracker:
             cls._instance = cls()
         return cls._instance
 
+    def _params_for(self, model_ref: str) -> tuple[float, int]:
+        """Return (failure_ttl, max_failures) for a model based on provider."""
+        if model_ref in self._failure_ttls:
+            return self._failure_ttls[model_ref], self._max_failures_map[model_ref]
+        if model_ref.startswith("zen/"):
+            return self._failure_ttl_zen, self._max_failures_zen
+        if model_ref.startswith("nvidia_nim/"):
+            return self._failure_ttl_nim, self._max_failures_nim
+        return self._failure_ttl, self._max_failures
+
     def record_failure(self, model_ref: str) -> None:
         """Record a failure timestamp for a model."""
         now = time.monotonic()
@@ -44,16 +69,17 @@ class ModelHealthTracker:
         """Check if model has had fewer than max_failures in the TTL window."""
         if model_ref not in self._failures:
             return True
-        cutoff = time.monotonic() - self._failure_ttl
+        ttl, max_f = self._params_for(model_ref)
+        cutoff = time.monotonic() - ttl
         recent = [t for t in self._failures[model_ref] if t > cutoff]
         self._failures[model_ref] = recent
-        healthy = len(recent) < self._max_failures
+        healthy = len(recent) < max_f
         if not healthy:
             logger.debug(
                 "HEALTH: model '{}' is unhealthy ({} failures in {}s)",
                 model_ref,
                 len(recent),
-                self._failure_ttl,
+                ttl,
             )
         return healthy
 
@@ -61,7 +87,8 @@ class ModelHealthTracker:
         """Get number of recent failures for a model."""
         if model_ref not in self._failures:
             return 0
-        cutoff = time.monotonic() - self._failure_ttl
+        ttl, _ = self._params_for(model_ref)
+        cutoff = time.monotonic() - ttl
         return len([t for t in self._failures[model_ref] if t > cutoff])
 
     def clear_failures(self, model_ref: str) -> None: