refactor(device): remove single-device state and test branches

apps/admin_console/routers/system.py

@@ -111,7 +111,7 @@ async def select_active_device(request: SelectDeviceRequest):
     if not serial:
         raise HTTPException(status_code=400, detail="Device serial cannot be empty.")
 
-    readiness_engine.set_active_device_serial(serial)
+    readiness_engine.set_probe_target_serial(serial)
     # Return updated readiness
     report = await readiness_engine.run_all(force_refresh=True)
     return {
@@ -192,7 +192,7 @@ async def connect_adb_server(payload: ConnectAdbServerRequest, request: Request)
 
     response: dict[str, object] = {"connection_result": connection_result}
     if connection_result["success"]:
-        readiness_engine.set_active_device_serial(None)
+        readiness_engine.set_probe_target_serial(None)
         readiness_engine.invalidate_cache()
         response["report"] = await readiness_engine.run_all(force_refresh=True)
     return response
@@ -214,7 +214,7 @@ async def use_local_adb_server(request: Request, persist: bool = True):
     """Restore the standard local ADB server without touching a remote daemon."""
     _require_local_admin_request(request)
     connection_result = await adb_server_connection.use_local_server(persist=persist)
-    readiness_engine.set_active_device_serial(None)
+    readiness_engine.set_probe_target_serial(None)
     readiness_engine.invalidate_cache()
     updated_report = await readiness_engine.run_all(force_refresh=True)
     return {

apps/admin_console/routers/tasks.py

@@ -140,7 +140,10 @@ async def run_task(request: RunRequest):
     # polling intervals cannot start through a stale Ready state. Use the
     # bounded submission probe: the full diagnostics path also scans packages,
     # emulator installations, Android version, and screen size.
-    target_serial = request.device_serial or readiness_engine.get_active_device_serial()
+    # With no explicit serial the probe itself resolves a live target (it
+    # prefers the diagnostics target preference, then any unlocked ready
+    # device); the verified serial is bound below.
+    target_serial = request.device_serial
     device_probe = await readiness_engine.run_device_submission_probe(
         target_serial=target_serial
     )
@@ -164,10 +167,6 @@ async def run_task(request: RunRequest):
         # invalid, enqueue_tasks rejects the submission with a clear error.
         if verified_serial and not request.device_serial:
             target_serial = verified_serial
-        # The probe verified a live device either way: keep the global active
-        # serial in sync even when the caller pinned the target explicitly.
-        if verified_serial and readiness_engine.get_active_device_serial() != verified_serial:
-            readiness_engine.set_active_device_serial(verified_serial)
 
     return await task_queue_service.enqueue_tasks(
         incoming_goals,

apps/admin_console/services/task_queue_service.py

@@ -767,13 +767,6 @@ class TaskQueueService:
         for i, goal in enumerate(goals):
             sess_id = (session_id if (session_id and len(goals) == 1) else str(uuid.uuid4()))
             assigned_serial = device_serial
-            if not assigned_serial:
-                try:
-                    from artemis.core.diagnostics import readiness_engine
-
-                    assigned_serial = readiness_engine.get_active_device_serial()
-                except Exception:
-                    assigned_serial = None
             if not assigned_serial:
                 try:
                     from artemis.runtime import device_pool
@@ -949,21 +942,18 @@ class TaskQueueService:
                     owner = dev_owner
                     break
         if owner is None:
+            # Covers scoped/legacy lock records that get_active_owners cannot
+            # key by session or device. A stale owner for a different session
+            # is never adopted: with no live owner, a session-targeted stop
+            # falls through to the queue/session-repository fallbacks below.
             fallback_owner = DeviceExecutionLock.get_active_owner(target_device)
-            if fallback_owner:
-                if not target_sid or (
-                    fallback_owner.session_id and str(fallback_owner.session_id) == target_sid
-                ):
-                    owner = fallback_owner
-                elif not active_owners:
-                    # In unit tests, get_active_owners is unmocked (empty), while get_active_owner is mocked
-                    owner = fallback_owner
+            if fallback_owner and (
+                not target_sid
+                or (fallback_owner.session_id and str(fallback_owner.session_id) == target_sid)
+            ):
+                owner = fallback_owner
 
-        owner_record_exists = (
-            DeviceExecutionLock.has_owner_record(target_device)
-            if hasattr(DeviceExecutionLock, "has_owner_record")
-            else False
-        )
+        owner_record_exists = DeviceExecutionLock.has_owner_record(target_device)
         owner_pid = owner.pid if owner else None
 
         # Resolve the locally-managed run for this target (concurrent scheduling
@@ -981,8 +971,16 @@ class TaskQueueService:
                 None,
             )
         elif len(state.active_runs) == 1:
+            # Untargeted stop (legacy single-device gesture): with exactly one
+            # live run the target is unambiguous. With several runs no run is
+            # resolved -- callers must target a session or device explicitly.
             local_run = next(iter(state.active_runs.values()))
-        local_proc = (local_run or {}).get("process") or state.current_process
+        local_proc = (local_run or {}).get("process")
+        if local_proc is None and not state.active_runs:
+            # Legacy fallback for the window without per-run bookkeeping. With
+            # live active_runs, current_process belongs to the newest run and
+            # must not stand in for an unresolved target.
+            local_proc = state.current_process
         local_pid = getattr(local_proc, "pid", None)
         is_local_owner = bool(owner_pid and local_pid and owner_pid == local_pid)