feat(console): add Artemis Admin & Trace Console backend and management plane

Introduces the comprehensive developer/administrator control plane and trace
inspection console backend for the ARTEMIS mobile automation platform.

Key Features & Backend Architecture:
- Core Server & Modular Routing:
  * FastAPI modular architecture with dedicated routers for sessions, steps, tasks, media, stream, and replay.
  * Multi-layer repository pattern with SQLite persistence for sessions, traces, and step data.
- Task Control & Queue Management:
  * FIFO asynchronous task queue service with support for single/batch goal execution and profile selection (Flash / Pro).
  * Session lifecycle controls (run, pause, resume, stop, clear queue).
  * Startup orphan cleanup and automatic older replay archiving.
- Live Telemetry & IPC Communication:
  * High-performance IPC server for streaming real-time execution logs, agent thoughts, and tool invocations.
  * Server-Sent Events (SSE) /api/stream/{session_id} endpoint for live UI updates.
- Real-Time Device Streaming:
  * Live ADB screen capture and MJPEG frame generator (/api/stream/device-live).
  * Device connectivity and state inspection endpoint (/api/stream/device-state).
- Trace Inspection & Step Replay Engine:
  * Hierarchical call tree inspection, pre/post step screenshots, and action overlay metadata.
  * Isolated single-step replay manager (/api/replay) for interactive debugging and validation.

apps/admin_console/services/model_service.py

@@ -0,0 +1,133 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import Any
+
+
+class ModelService:
+    """Service handling model profile detection and metadata formatting."""
+
+    @staticmethod
+    def get_active_model_info(profile: str | None = None) -> dict[str, str]:
+        if profile:
+            p_lower = str(profile).lower()
+            if "pro" in p_lower:
+                return {
+                    "name": "Pro",
+                    "id": "gemini-3.6-pro",
+                    "provider": "google",
+                }
+            elif "flash" in p_lower:
+                return {
+                    "name": "Flash",
+                    "id": "gemini-3.6-flash",
+                    "provider": "google",
+                }
+
+        model_name = "Flash"
+        model_id = "gemini-3.6-flash"
+        provider = "google"
+        try:
+            from artemis.config import parse_llm_config
+
+            llm_cfg = parse_llm_config()
+            if llm_cfg and llm_cfg.operator:
+                op_model = str(llm_cfg.operator.model).lower()
+                provider = str(llm_cfg.operator.provider)
+                model_id = llm_cfg.operator.model
+                if "pro" in op_model:
+                    model_name = "Pro"
+                elif "flash" in op_model:
+                    model_name = "Flash"
+                else:
+                    model_name = llm_cfg.operator.model.capitalize()
+        except Exception:
+            pass
+        return {"name": model_name, "id": model_id, "provider": provider}
+
+    @staticmethod
+    def resolve_session_profile(
+        row_dict: dict[str, Any],
+        llm_trace_payloads: list[str] | None = None,
+        running_profile: str | None = None,
+        agent_names: list[str] | None = None,
+    ) -> str | None:
+        sess_profile = None
+        d_info_raw = row_dict.get("device_info")
+        if d_info_raw:
+            try:
+                d_info = json.loads(d_info_raw) if isinstance(d_info_raw, str) else d_info_raw
+                if isinstance(d_info, dict):
+                    p = d_info.get("profile")
+                    if p:
+                        p_str = str(p).lower()
+                        if "pro" in p_str:
+                            return "pro"
+                        elif "flash" in p_str:
+                            return "flash"
+            except Exception:
+                pass
+
+        if (row_dict.get("status") == "running") and running_profile:
+            p_str = str(running_profile).lower()
+            if "pro" in p_str:
+                return "pro"
+            elif "flash" in p_str:
+                return "flash"
+
+        # Check Agent/Trace names - the most definitive indicator of architecture
+        if agent_names:
+            agent_names_lower = [str(a).lower() for a in agent_names]
+            if any(
+                name in ("planner", "validator", "summarizer", "operator", "checker", "diagnoser")
+                for name in agent_names_lower
+            ):
+                return "pro"
+            if any("flashrunner" in name for name in agent_names_lower):
+                return "flash"
+
+        # Check LLM traces for agent name or model overrides
+        if llm_trace_payloads:
+            for tr_payload in llm_trace_payloads:
+                if tr_payload:
+                    try:
+                        p_obj = (
+                            json.loads(tr_payload) if isinstance(tr_payload, str) else tr_payload
+                        )
+                        if isinstance(p_obj, dict):
+                            agent_name = str(p_obj.get("agent") or p_obj.get("name") or "").lower()
+                            if "flashrunner" in agent_name:
+                                return "flash"
+                            if any(
+                                x in agent_name
+                                for x in ("planner", "validator", "operator", "checker")
+                            ):
+                                return "pro"
+
+                            m_str = str(p_obj.get("model") or p_obj.get("model_name") or "").lower()
+                            if (
+                                "gemini-3.6-pro" in m_str
+                                or "gemini-1.5-pro" in m_str
+                                or "gpt-4" in m_str
+                                or "claude" in m_str
+                            ):
+                                return "pro"
+                    except Exception:
+                        pass
+
+        return None
+
+
+model_service = ModelService()