infinicode 2.8.35 → 2.8.37

package/packages/robopark/scheduler/main.py

@@ -5,11 +5,13 @@ Manages robot fleet, LiveKit servers, and session orchestration
 
 import os
 import asyncio
+import json
 import logging
 import re
 import secrets
 import hashlib
 import hmac
+import time
 from datetime import datetime, timedelta
 from typing import Optional, List
 from contextlib import asynccontextmanager
@@ -31,6 +33,26 @@ DB_PATH = os.path.join(os.getenv("SCHEDULER_DATA_DIR", "/app/data"), "scheduler.
 # Path to a ROBOVOICE-style settings file the scheduler reads for characters.
 # In production this should be a bind-mount to ROBOVOICE-main/settings.json (or .default.json).
 ROBOVOICE_SETTINGS_PATH = os.path.join(os.getenv("SCHEDULER_DATA_DIR", "/app/data"), "robovoice_settings.json")
+# Optional shared credential used only by the ROBOVOICE worker to refresh an
+# active RoboPark session. Device endpoints continue to require device tokens.
+ROBOPARK_AGENT_TOKEN = os.getenv("ROBOPARK_AGENT_TOKEN", "").strip()
+
+# ElevenLabs credentials used by the /api/voices/elevenlabs endpoint. We accept
+# both the long-form ELEVENLABS_API_KEY and a shorter ELEVENLABS_KEY alias so
+# operators can drop in whichever naming their tooling already exports. Either
+# may be set in the scheduler's environment.
+ELEVENLABS_API_KEY = (
+    os.getenv("ELEVENLABS_API_KEY", "").strip()
+    or os.getenv("ELEVENLABS_KEY", "").strip()
+    or os.getenv("ELEVEN_API_KEY", "").strip()
+)
+ELEVENLABS_BASE_URL = os.getenv("ELEVENLABS_BASE_URL", "https://api.elevenlabs.io").rstrip("/")
+
+# Optional base URL of a local Kokoro TTS server. When set, /api/voices/kokoro
+# will proxy its /v1/audio/voices endpoint to return the dynamic list of voices
+# the server actually has installed; otherwise we fall back to a curated static
+# list of the canonical Kokoro-82M voices.
+KOKORO_BASE_URL = os.getenv("KOKORO_BASE_URL", "").strip().rstrip("/")
 
 # Session end_reasons considered "abnormal" for drop-rate telemetry. A session
 # that ended with one of these reasons is counted as a dropped session; anything
@@ -106,6 +128,15 @@ class WebhookEvent(BaseModel):
     event: str
     data: dict
 
+class ServiceStatus(BaseModel):
+    name: str
+    enabled: bool
+    running: bool
+    pid: Optional[int] = None
+    uptime_seconds: Optional[float] = None
+    failure_count: int = 0
+    last_exit_code: Optional[int] = None
+
 class Device(BaseModel):
     id: str
     name: str
@@ -116,6 +147,12 @@ class Device(BaseModel):
     livekit_url: Optional[str] = None
     video_device: Optional[str] = None
     audio_device: Optional[str] = None
+    audio_output_device: Optional[str] = None
+    greeting_phrases: List[str] = []
+    device_inventory: Optional[dict] = None
+    production_mode: bool = False
+    supervisor_status: Optional[List[ServiceStatus]] = None
+    supervisor_status_at: Optional[str] = None
     status: str = "enrolled"  # enrolled, online, offline, disabled
     last_heartbeat: Optional[datetime] = None
     enrolled_at: Optional[datetime] = None
@@ -132,6 +169,7 @@ class DeviceCreate(BaseModel):
     livekit_url: Optional[str] = None
     video_device: Optional[str] = None
     audio_device: Optional[str] = None
+    greeting_phrases: Optional[List[str]] = None
     notes: Optional[str] = None
     enrollment_token: Optional[str] = None  # if omitted, one is auto-generated
 
@@ -156,6 +194,10 @@ class DeviceHeartbeat(BaseModel):
     ip: Optional[str] = None
     uptime_seconds: Optional[int] = None
     production_mode: Optional[bool] = None
+    device_inventory: Optional[dict] = None
+
+class SupervisorStatusReport(BaseModel):
+    services: List[ServiceStatus] = []
 
 class SettingsPayload(BaseModel):
     production_mode: bool
@@ -194,14 +236,14 @@ async def _seed_voice_stacks_and_characters(db):
         (
             "english-default", "English Default",
             "speaches", "Systran/faster-whisper-small", "en",
-            "ollama", "gemma4:e4b",
+            "ollama", "gemma3:27b",
             "elevenlabs", "21m00Tcm4TlvDq8ikWAM", "en",
             1, 0.7, 20, 0,
         ),
         (
             "hebrew-default", "Hebrew Default",
             "speaches", "ivrit-ai/whisper-large-v3-turbo-ct2", "he",
-            "ollama", "gemma4:e4b",
+            "ollama", "gemma3:27b",
             "elevenlabs", "21m00Tcm4TlvDq8ikWAM", "he",
             1, 0.7, 20, 0,
         ),
@@ -297,9 +339,11 @@ async def init_db():
                 motor_server_url TEXT,
                 character_id TEXT,
                 livekit_url TEXT,
-                video_device TEXT,
-                audio_device TEXT,
-                token_hash TEXT,
+                 video_device TEXT,
+                  audio_device TEXT,
+                  audio_output_device TEXT,
+                  device_inventory TEXT,
+                 token_hash TEXT,
                 enrollment_token_hash TEXT,
                 status TEXT DEFAULT 'enrolled',
                 last_heartbeat TEXT,
@@ -323,6 +367,26 @@ async def init_db():
                 created_at TEXT DEFAULT CURRENT_TIMESTAMP
             );
 
+            CREATE TABLE IF NOT EXISTS trigger_commands (
+                robot_id TEXT PRIMARY KEY,
+                source TEXT NOT NULL DEFAULT 'dashboard',
+                requested_at TEXT NOT NULL
+            );
+
+            -- One pending remote-control command per (device, service): an
+            -- operator clicking "restart" in the dashboard queues a row here;
+            -- robot_supervisor.py polls GET .../supervisor-commands (same
+            -- request that carries its status report) and executes+clears it.
+            -- A second click before the robot polls just overwrites the row
+            -- rather than queuing duplicates.
+            CREATE TABLE IF NOT EXISTS supervisor_commands (
+                device_id TEXT NOT NULL,
+                service_name TEXT NOT NULL,
+                action TEXT NOT NULL DEFAULT 'restart',
+                requested_at TEXT NOT NULL,
+                PRIMARY KEY (device_id, service_name)
+            );
+
             CREATE TABLE IF NOT EXISTS history_log (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
@@ -342,7 +406,7 @@ async def init_db():
                 stt_model TEXT DEFAULT 'Systran/faster-whisper-small',
                 stt_language TEXT DEFAULT 'en',
                 llm_provider TEXT DEFAULT 'ollama',
-                llm_model TEXT DEFAULT 'gemma4:e4b',
+                llm_model TEXT DEFAULT 'gemma3:27b',
                 tts_provider TEXT DEFAULT 'elevenlabs',
                 tts_voice TEXT DEFAULT '21m00Tcm4TlvDq8ikWAM',
                 tts_language TEXT DEFAULT 'en',
@@ -398,6 +462,22 @@ async def init_db():
             ("sessions", "joined_at", "TEXT"),
             ("devices", "video_device", "TEXT"),
             ("devices", "audio_device", "TEXT"),
+            ("devices", "device_inventory", "TEXT"),
+            ("devices", "audio_output_device", "TEXT"),
+            ("devices", "greeting_phrases", "TEXT DEFAULT '[]'"),
+            # Per-robot production mode: an additional, more specific gate on
+            # top of the global settings.production_mode switch. When on for
+            # a given device, that robot keeps re-arming its motion-triggered
+            # session loop indefinitely (device_heartbeat below returns the
+            # AND of global+per-device as the effective flag the Pi acts on)
+            # and the dashboard keeps that robot's camera panel live.
+            ("devices", "production_mode", "INTEGER DEFAULT 0"),
+            # robot_supervisor.py's own periodic self-report: which services
+            # it's managing on this robot (preview_agent, vision_app,
+            # motor_server) and each one's up/down state, pid, uptime, and
+            # failure count. JSON blob; see POST .../supervisor-status.
+            ("devices", "supervisor_status", "TEXT"),
+            ("devices", "supervisor_status_at", "TEXT"),
             # Silence-based session end (see POST /api/sessions/{id}/keepalive
             # and GET /api/sessions/{id}/status): tracks the last time some
             # caller signaled this session was still active. Defaults to
@@ -483,6 +563,16 @@ async def init_db():
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     await init_db()
+    if not ROBOPARK_AGENT_TOKEN:
+        logger.warning(
+            "ROBOPARK_AGENT_TOKEN is not set -- the voice agent's "
+            "POST /api/sessions/{id}/keepalive calls will all 401. Without "
+            "keepalive succeeding, every motion-triggered session's "
+            "last_activity_at never updates and gets cut off by its own "
+            "silence timeout within ~15s, before a greeting or any real "
+            "conversation can complete. Set it to match ROBOPARK_AGENT_TOKEN "
+            "in the voice agent's own .env before relying on production mode."
+        )
     asyncio.create_task(metrics_collector())
     asyncio.create_task(health_checker())
     yield
@@ -732,9 +822,10 @@ async def end_session(robot_id: str, reason: str = "silence"):
             robot = await cursor.fetchone()
             if not robot or not robot["current_session_id"]:
                 raise HTTPException(400, "No active session")
+            current_session_id = robot["current_session_id"]
         
         # Update session
-        async with db.execute("SELECT * FROM sessions WHERE id = ?", (robot["current_session_id"],)) as cursor:
+        async with db.execute("SELECT * FROM sessions WHERE id = ?", (current_session_id,)) as cursor:
             session = await cursor.fetchone()
             if session:
                 started = datetime.fromisoformat(session["started_at"])
@@ -759,9 +850,86 @@ async def end_session(robot_id: str, reason: str = "silence"):
         await db.commit()
     
     await broadcast("session_ended", {"robot_id": robot_id, "reason": reason})
-    await _log_history("session", "robot", robot_id, "session_ended", "robot", f"reason={reason}, session_id={robot.get('current_session_id')}")
+    await _log_history("session", "robot", robot_id, "session_ended", "robot", f"reason={reason}, session_id={current_session_id}")
     return {"status": "ok"}
 
+@app.post("/api/robots/{robot_id}/simulate-trigger")
+async def simulate_trigger(robot_id: str):
+    """Queue a dashboard motion event for the enrolled robot."""
+    if not await get_production_mode():
+        return {"queued": False, "reason": "production_mode_off"}
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT id, current_session_id FROM robots WHERE id = ?", (robot_id,)
+        ) as c:
+            robot = await c.fetchone()
+        if not robot:
+            raise HTTPException(404, "Robot not found")
+        if robot["current_session_id"]:
+            return {"queued": False, "reason": "session_active"}
+        await db.execute(
+            "INSERT INTO trigger_commands (robot_id, source, requested_at) VALUES (?, ?, ?) "
+            "ON CONFLICT(robot_id) DO UPDATE SET source = excluded.source, requested_at = excluded.requested_at",
+            (robot_id, "dashboard", datetime.utcnow().isoformat()),
+        )
+        await db.commit()
+    await broadcast("robot_triggered", {"robot_id": robot_id, "source": "dashboard"})
+    await _log_history("robot", "robot", robot_id, "simulate_trigger", "operator")
+    return {"queued": True, "source": "dashboard"}
+
+@app.post("/api/robots/{robot_id}/simulate-stop")
+async def simulate_stop(robot_id: str):
+    """Stop a simulated or production conversation and release the robot."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT current_session_id FROM robots WHERE id = ?", (robot_id,)
+        ) as c:
+            robot = await c.fetchone()
+        if not robot:
+            raise HTTPException(404, "Robot not found")
+        await db.execute("DELETE FROM trigger_commands WHERE robot_id = ?", (robot_id,))
+        await db.commit()
+    stopped = False
+    if robot["current_session_id"]:
+        try:
+            await end_session(robot_id, "operator_stop")
+            stopped = True
+        except HTTPException:
+            pass
+    await _log_history("robot", "robot", robot_id, "simulate_stop", "operator")
+    return {"stopped": stopped}
+
+@app.post("/api/robots/{robot_id}/recover")
+async def recover_robot(robot_id: str):
+    """Clear this robot's stale session/trigger state and return it to idle.
+
+    This is intentionally scoped to one robot. It does not restart workers or
+    touch other robots, and is safe to repeat after a failed LiveKit teardown.
+    """
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute("SELECT id, current_session_id FROM robots WHERE id = ?", (robot_id,)) as c:
+            robot = await c.fetchone()
+        if not robot:
+            raise HTTPException(404, "Robot not found")
+        await db.execute(
+            "UPDATE sessions SET ended_at = COALESCE(ended_at, ?), end_reason = COALESCE(end_reason, 'operator_recovery') "
+            "WHERE robot_id = ? AND ended_at IS NULL",
+            (now, robot_id),
+        )
+        await db.execute("DELETE FROM trigger_commands WHERE robot_id = ?", (robot_id,))
+        await db.execute(
+            "UPDATE robots SET status = 'idle', current_session_id = NULL, connected_server_id = NULL WHERE id = ?",
+            (robot_id,),
+        )
+        await db.commit()
+    await broadcast("robot_recovered", {"robot_id": robot_id})
+    await _log_history("robot", "robot", robot_id, "recovered", "operator")
+    return {"status": "ok", "robot_id": robot_id, "previous_session_id": robot["current_session_id"]}
+
 @app.post("/api/robots/{robot_id}/trigger")
 async def robot_trigger(robot_id: str,
                         authorization: Optional[str] = Header(default=None)):
@@ -1047,7 +1215,8 @@ async def session_joined(session_id: str,
 
 @app.post("/api/sessions/{session_id}/keepalive")
 async def session_keepalive(session_id: str,
-                            authorization: Optional[str] = Header(default=None)):
+                            authorization: Optional[str] = Header(default=None),
+                            agent_token: Optional[str] = Header(default=None, alias="X-RoboPark-Agent-Token")):
     """Silence-based session extension signal.
 
     INTEGRATION POINT (out of scope here — lives in a different repo): the
@@ -1066,7 +1235,13 @@ async def session_keepalive(session_id: str,
     ceiling regardless of activity, so a misbehaving/stuck caller can never
     hold the publisher forever even if it calls this endpoint continuously.
     """
-    if not await _authorize_fleet(authorization):
+    device_authorized = await _authorize_fleet(authorization)
+    agent_authorized = bool(
+        ROBOPARK_AGENT_TOKEN
+        and agent_token
+        and hmac.compare_digest(agent_token.strip(), ROBOPARK_AGENT_TOKEN)
+    )
+    if not device_authorized and not agent_authorized:
         raise HTTPException(401, "Invalid or missing device token")
     now = datetime.utcnow().isoformat()
     async with aiosqlite.connect(DB_PATH) as db:
@@ -1248,6 +1423,11 @@ async def metrics_collector():
                     try:
                         async with httpx.AsyncClient(timeout=5.0) as client:
                             resp = await client.get(f"{server['webhook_url']}/metrics")
+                            if resp.status_code == 404:
+                                # Bare LiveKit servers do not expose the agent metrics endpoint.
+                                logger.debug(f"Metrics endpoint unavailable for {server['id']}")
+                                continue
+                            resp.raise_for_status()
                             data = resp.json()
                             
                             # Store in history
@@ -1323,6 +1503,33 @@ async def health_checker():
                     await db.execute("UPDATE devices SET status = 'offline' WHERE id = ?", (did,))
                     await broadcast("device_status_changed", {"device_id": did, "status": "offline"})
 
+                # Reap sessions leaked by a crashed worker or broken LiveKit
+                # disconnect. Normal sessions are closed by the worker, but
+                # this prevents stale rooms consuming server capacity forever.
+                session_cutoff = (datetime.utcnow() - timedelta(seconds=120)).isoformat()
+                async with db.execute(
+                    "SELECT id, robot_id FROM sessions "
+                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ?",
+                    (session_cutoff,),
+                ) as c:
+                    stale_sessions = await c.fetchall()
+                for session in stale_sessions:
+                    await db.execute(
+                        "UPDATE sessions SET ended_at = ?, end_reason = 'silence' "
+                        "WHERE id = ? AND ended_at IS NULL",
+                        (datetime.utcnow().isoformat(), session["id"]),
+                    )
+                    await db.execute(
+                        "UPDATE robots SET status = 'idle', current_session_id = NULL, "
+                        "connected_server_id = NULL WHERE id = ? AND current_session_id = ?",
+                        (session["robot_id"], session["id"]),
+                    )
+                    await broadcast("session_expired", {
+                        "session_id": session["id"],
+                        "robot_id": session["robot_id"],
+                        "reason": "silence",
+                    })
+
                 await db.commit()
         
         except Exception as e:
@@ -1348,6 +1555,20 @@ async def get_settings():
 async def update_settings(payload: SettingsPayload):
     """Update scheduler settings (production mode, etc.)."""
     await set_setting("production_mode", "true" if payload.production_mode else "false")
+    if not payload.production_mode:
+        async with aiosqlite.connect(DB_PATH) as db:
+            async with db.execute(
+                "SELECT id FROM robots WHERE current_session_id IS NOT NULL"
+            ) as c:
+                active_robot_ids = [row[0] for row in await c.fetchall()]
+            await db.execute("DELETE FROM trigger_commands")
+            await db.execute("DELETE FROM previews")
+            await db.commit()
+        for robot_id in active_robot_ids:
+            try:
+                await end_session(robot_id, "production_mode_off")
+            except HTTPException:
+                pass
     await broadcast("settings_changed", {"production_mode": payload.production_mode})
     await _log_history("settings", "settings", "production_mode", "updated", "operator", f"value={payload.production_mode}")
     return {"status": "ok", "production_mode": payload.production_mode}
@@ -1589,6 +1810,27 @@ async def robot_stream(robot_id: str,
 PREVIEW_TTL_SECONDS = 45  # preview auto-expires this long after the last keepalive
 DEFAULT_VISION_PORT = 5000  # RoboVisionAI_PI's default Flask port (/video_feed, /api/motion/*)
 
+async def _mirror_device_to_robot(db, device_id: str):
+    """Ensure a `robots` row exists for an enrolled device, so id-keyed routes
+    (/stream, /preview/*) work even before the device's first real voice
+    session (device_request_session normally creates this mirror, but only on
+    first request-session — operator "Go live" should work before that too)."""
+    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
+        robot = await c.fetchone()
+    if robot:
+        return robot
+    async with db.execute("SELECT * FROM devices WHERE id = ?", (device_id,)) as c:
+        device = await c.fetchone()
+    if not device:
+        return None
+    await db.execute(
+        "INSERT OR IGNORE INTO robots (id, name, character_id) VALUES (?, ?, ?)",
+        (device_id, device["name"] or device_id, device["character_id"]),
+    )
+    await db.commit()
+    async with db.execute("SELECT * FROM robots WHERE id = ?", (device_id,)) as c:
+        return await c.fetchone()
+
 async def _pick_preview_server(db, prefer_id: Optional[str] = None):
     """Return a LiveKit server row for a preview: a preferred one if still present,
     else the least-loaded online server, else any configured server."""
@@ -1638,9 +1880,8 @@ async def preview_start(robot_id: str):
         return {"active": False, "reason": "production_mode_off"}
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
-        async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as c:
-            if not await c.fetchone():
-                raise HTTPException(404, "Robot not found")
+        if not await _mirror_device_to_robot(db, robot_id):
+            raise HTTPException(404, "Robot not found")
         async with db.execute("SELECT * FROM previews WHERE robot_id = ?", (robot_id,)) as c:
             existing = await c.fetchone()
         server = await _pick_preview_server(db, existing["server_id"] if existing else None)
@@ -1724,6 +1965,26 @@ def _device_row_to_model(row) -> Device:
     d = dict(row)
     d.pop("token_hash", None)
     d.pop("enrollment_token_hash", None)
+    inventory = d.get("device_inventory")
+    if isinstance(inventory, str):
+        try:
+            d["device_inventory"] = json.loads(inventory)
+        except json.JSONDecodeError:
+            d["device_inventory"] = None
+    greetings = d.get("greeting_phrases")
+    if isinstance(greetings, str):
+        try:
+            d["greeting_phrases"] = [str(p) for p in json.loads(greetings) if str(p).strip()]
+        except (json.JSONDecodeError, TypeError):
+            d["greeting_phrases"] = []
+    elif not isinstance(greetings, list):
+        d["greeting_phrases"] = []
+    sup = d.get("supervisor_status")
+    if isinstance(sup, str):
+        try:
+            d["supervisor_status"] = json.loads(sup)
+        except json.JSONDecodeError:
+            d["supervisor_status"] = None
     return Device(**d)
 
 @app.get("/api/devices", response_model=List[Device])
@@ -1782,15 +2043,24 @@ class DeviceUpdate(BaseModel):
     livekit_url: Optional[str] = None
     video_device: Optional[str] = None
     audio_device: Optional[str] = None
+    audio_output_device: Optional[str] = None
+    greeting_phrases: Optional[List[str]] = None
     tailscale_ip: Optional[str] = None
     lan_ip: Optional[str] = None
     notes: Optional[str] = None
     status: Optional[str] = None
+    production_mode: Optional[bool] = None
 
 @app.patch("/api/devices/{device_id}", response_model=Device)
 async def update_device(device_id: str, payload: DeviceUpdate):
     """Partial update for a device (character binding, addresses, notes, status)."""
     fields = {k: v for k, v in payload.model_dump(exclude_none=True).items()}
+    if "greeting_phrases" in fields:
+        fields["greeting_phrases"] = json.dumps(
+            [str(p).strip() for p in fields["greeting_phrases"] if str(p).strip()][:20]
+        )
+    if "production_mode" in fields:
+        fields["production_mode"] = 1 if fields["production_mode"] else 0
     if not fields:
         return await get_device(device_id)
     set_clause = ", ".join(f"{k} = ?" for k in fields)
@@ -1847,13 +2117,13 @@ async def create_device(payload: DeviceCreate):
             """INSERT INTO devices
                (id, name, tailscale_ip, lan_ip, motor_server_url, character_id,
                 livekit_url, video_device, audio_device, enrollment_token_hash,
-                status, enrolled_at, notes, created_at)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?, ?)""",
+                greeting_phrases, status, enrolled_at, notes, created_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?, ?)""",
             (
                 device_id, payload.name.strip(), payload.tailscale_ip, payload.lan_ip,
                 payload.motor_server_url, payload.character_id, payload.livekit_url,
                 payload.video_device, payload.audio_device,
-                enrollment_hash, now, payload.notes, now,
+                enrollment_hash, json.dumps(payload.greeting_phrases or []), now, payload.notes, now,
             ),
         )
         await db.commit()
@@ -2051,35 +2321,131 @@ async def enroll_device(payload: DeviceEnrollRequest):
     scheduler_url = os.getenv("SCHEDULER_PUBLIC_URL", f"http://localhost:{os.getenv('SCHEDULER_PORT', '8080')}")
     return DeviceEnrollResponse(device_id=device_id, device_token=new_token, scheduler_url=scheduler_url)
 
+async def _effective_device_production_mode(db, device_id: str) -> bool:
+    """Global master switch AND this robot's own toggle. Used everywhere a
+    robot decides whether to auto-trigger/stay in its motion-triggered loop."""
+    if not await get_production_mode():
+        return False
+    db.row_factory = aiosqlite.Row
+    async with db.execute("SELECT production_mode FROM devices WHERE id = ?", (device_id,)) as c:
+        row = await c.fetchone()
+    return bool(row["production_mode"]) if row else False
+
+@app.get("/api/devices/{device_id}/trigger-command")
+async def device_trigger_command(device_id: str,
+                                 authorization: Optional[str] = Header(default=None)):
+    """Authenticated robot poll for dashboard-simulated motion events."""
+    if not await _authorize_device(device_id, authorization):
+        raise HTTPException(401, "Invalid device token")
+    async with aiosqlite.connect(DB_PATH) as db:
+        if not await _effective_device_production_mode(db, device_id):
+            return {"trigger": False, "production_mode": False}
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT source FROM trigger_commands WHERE robot_id = ?", (device_id,)
+        ) as c:
+            command = await c.fetchone()
+        if not command:
+            return {"trigger": False, "production_mode": True}
+        await db.execute("DELETE FROM trigger_commands WHERE robot_id = ?", (device_id,))
+        await db.commit()
+    return {"trigger": True, "source": command["source"], "production_mode": True}
+
 @app.post("/api/devices/{device_id}/heartbeat")
 async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
                             authorization: Optional[str] = Header(default=None)):
     if not await _authorize_device(device_id, authorization):
         raise HTTPException(401, "Invalid device token")
     async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
         async with db.execute(
             """UPDATE devices
-               SET status = ?, last_heartbeat = ?, last_seen_ip = COALESCE(?, last_seen_ip)
+               SET status = ?, last_heartbeat = ?,
+                   lan_ip = COALESCE(?, lan_ip),
+                   last_seen_ip = COALESCE(?, last_seen_ip),
+                   device_inventory = COALESCE(?, device_inventory)
                WHERE id = ?""",
             (
                 payload.status or "online",
                 datetime.utcnow().isoformat(),
                 payload.ip,
+                payload.ip,
+                json.dumps(payload.device_inventory) if payload.device_inventory is not None else None,
                 device_id,
             ),
         ) as cur:
             await db.commit()
             if cur.rowcount == 0:
                 raise HTTPException(404, "Device not found")
+        effective_pm = await _effective_device_production_mode(db, device_id)
     await broadcast("device_heartbeat", {"device_id": device_id, "status": payload.status})
     await _log_history("device", "device", device_id, "heartbeat", "pi", f"status={payload.status or 'online'}, ip={payload.ip}")
-    # Tell the Pi whether production mode is on (so it can decide to join LiveKit or stand by)
+    # Effective production mode = the global master switch AND this specific
+    # robot's own toggle. A robot with its own toggle off never auto-triggers
+    # sessions from motion, even while the fleet-wide switch is on.
     return {
         "status": "ok",
-        "production_mode": await get_production_mode(),
+        "production_mode": effective_pm,
         "server_time": datetime.utcnow().isoformat(),
     }
 
+@app.post("/api/devices/{device_id}/supervisor-status")
+async def device_supervisor_status(device_id: str, payload: SupervisorStatusReport,
+                                    authorization: Optional[str] = Header(default=None)):
+    """robot_supervisor.py's periodic self-report: which services it's
+    managing on this robot and each one's current up/down state. Reported
+    independently of device_heartbeat (which comes from preview_agent.py --
+    if preview_agent itself is down, it can't report that fact, only the
+    supervisor watching it from outside can)."""
+    if not await _authorize_device(device_id, authorization):
+        raise HTTPException(401, "Invalid device token")
+    blob = json.dumps([s.model_dump() for s in payload.services])
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        cur = await db.execute(
+            "UPDATE devices SET supervisor_status = ?, supervisor_status_at = ? WHERE id = ?",
+            (blob, now, device_id),
+        )
+        await db.commit()
+        if cur.rowcount == 0:
+            raise HTTPException(404, "Device not found")
+        # Piggyback any pending remote-control commands (operator clicked
+        # "restart" on a service) onto this same request/response cycle --
+        # the robot already calls this every 10s, no separate poll needed.
+        # Consumed immediately: read then delete, so a command fires once.
+        async with db.execute(
+            "SELECT service_name, action FROM supervisor_commands WHERE device_id = ?", (device_id,)
+        ) as c:
+            pending = [dict(r) for r in await c.fetchall()]
+        if pending:
+            await db.execute("DELETE FROM supervisor_commands WHERE device_id = ?", (device_id,))
+            await db.commit()
+    await broadcast("supervisor_status", {"device_id": device_id, "services": blob})
+    return {"status": "ok", "commands": pending}
+
+@app.post("/api/devices/{device_id}/services/{service_name}/restart")
+async def restart_device_service(device_id: str, service_name: str):
+    """Operator dashboard: queue a restart for one service on one robot's
+    supervisor. Picked up on the robot's next status-report poll (up to
+    ~10s later, not instant -- there's no persistent connection to the
+    robot, only its periodic check-ins)."""
+    now = datetime.utcnow().isoformat()
+    async with aiosqlite.connect(DB_PATH) as db:
+        cur = await db.execute("SELECT 1 FROM devices WHERE id = ?", (device_id,))
+        if not await cur.fetchone():
+            raise HTTPException(404, "Device not found")
+        await db.execute(
+            """INSERT INTO supervisor_commands (device_id, service_name, action, requested_at)
+               VALUES (?, ?, 'restart', ?)
+               ON CONFLICT(device_id, service_name) DO UPDATE SET
+                   action='restart', requested_at=excluded.requested_at""",
+            (device_id, service_name, now),
+        )
+        await db.commit()
+    await _log_history("device", "device", device_id, "service_restart_queued", "operator", f"service={service_name}")
+    return {"status": "queued", "service": service_name}
+
 @app.get("/api/devices/{device_id}/config")
 async def device_config(device_id: str, authorization: Optional[str] = Header(default=None)):
     """Pi polls this to learn current production_mode + assigned character, etc."""
@@ -2088,19 +2454,25 @@ async def device_config(device_id: str, authorization: Optional[str] = Header(de
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
         async with db.execute(
-            "SELECT id, name, character_id, motor_server_url, livekit_url FROM devices WHERE id = ?",
+            "SELECT id, name, character_id, motor_server_url, livekit_url, video_device, audio_device, audio_output_device, device_inventory, greeting_phrases FROM devices WHERE id = ?",
             (device_id,),
         ) as c:
             row = await c.fetchone()
             if not row:
                 raise HTTPException(404, "Device not found")
+        effective_pm = await _effective_device_production_mode(db, device_id)
     return {
         "device_id": row["id"],
         "name": row["name"],
         "character_id": row["character_id"],
         "motor_server_url": row["motor_server_url"],
         "livekit_url": row["livekit_url"],
-        "production_mode": await get_production_mode(),
+        "video_device": row["video_device"],
+        "audio_device": row["audio_device"],
+        "audio_output_device": row["audio_output_device"],
+        "greeting_phrases": _device_row_to_model(row).greeting_phrases,
+        "device_inventory": json.loads(row["device_inventory"]) if row["device_inventory"] else None,
+        "production_mode": effective_pm,
     }
 
 @app.post("/api/devices/{device_id}/request-session")
@@ -2150,6 +2522,21 @@ async def device_request_session(device_id: str,
             (device_id, device["name"] or device_id, device["character_id"]),
         )
 
+        # A robot can only physically be in one room at a time -- it always
+        # disconnects from its previous room before joining a new one (see
+        # preview_agent.py's _apply_state). But this endpoint deliberately
+        # never hard-fails on a prior un-ended session (see docstring), so
+        # without this, repeated presence-triggers (e.g. continuous motion
+        # detection) each leave the previous session's row with
+        # ended_at IS NULL forever -- permanently consuming a slot against
+        # the server's max_sessions capacity until every slot leaks away and
+        # every future request-session 503s. Close them out here instead.
+        await db.execute(
+            """UPDATE sessions SET ended_at = ?, end_reason = 'superseded'
+               WHERE robot_id = ? AND ended_at IS NULL""",
+            (datetime.utcnow().isoformat(), device_id),
+        )
+
         # Find least-loaded online server (identical selection to the robot path).
         async with db.execute("""
             SELECT s.*,
@@ -2287,7 +2674,7 @@ class VoiceStack(BaseModel):
     stt_model: str = "Systran/faster-whisper-small"
     stt_language: str = "en"
     llm_provider: str = "ollama"
-    llm_model: str = "gemma4:e4b"
+    llm_model: str = "gemma3:27b"
     llm_api_key: Optional[str] = None
     temperature: float = 0.7
     num_ctx: int = 8192
@@ -2311,7 +2698,7 @@ class VoiceStackCreate(BaseModel):
     stt_model: str = "Systran/faster-whisper-small"
     stt_language: str = "en"
     llm_provider: str = "ollama"
-    llm_model: str = "gemma4:e4b"
+    llm_model: str = "gemma3:27b"
     llm_api_key: Optional[str] = None
     temperature: float = 0.7
     num_ctx: int = 8192
@@ -2333,6 +2720,7 @@ class RobotVoiceConfig(BaseModel):
     system_prompt: Optional[str] = None
     voice_stack_id: Optional[str] = None
     voice_stack: Optional[VoiceStack] = None
+    greeting_phrases: List[str] = []
 
 def _load_robovoice_settings() -> dict:
     """Read the ROBOVOICE settings file. Returns {} if missing/invalid."""
@@ -2453,6 +2841,48 @@ async def _resolve_voice_stack_for_robot(db, robot_id: str) -> dict:
     return result
 
 
+_ELEVENLABS_NAME_CACHE: tuple[float, list[dict]] = (0.0, [])
+
+
+async def _auto_elevenlabs_voice(robot_name: Optional[str], current: Optional[str]) -> Optional[str]:
+    """Resolve a custom ElevenLabs voice by robot name without overwriting a manual choice."""
+    if current and current != "21m00Tcm4TlvDq8ikWAM":
+        return current
+    if not robot_name:
+        return current
+    normalized = "".join(ch for ch in robot_name.lower() if ch.isalnum())
+    try:
+        mapping = json.loads(os.getenv("ROBOPARK_ELEVENLABS_VOICE_MAP", "{}"))
+        for key, voice_id in mapping.items():
+            if "".join(ch for ch in str(key).lower() if ch.isalnum()) in (normalized, "".join(ch for ch in robot_name.lower() if ch.isalnum())):
+                return str(voice_id)
+    except Exception:
+        pass
+    global _ELEVENLABS_NAME_CACHE
+    now = time.monotonic()
+    voices = _ELEVENLABS_NAME_CACHE[1]
+    if now - _ELEVENLABS_NAME_CACHE[0] > 300 and ELEVENLABS_API_KEY:
+        try:
+            async with httpx.AsyncClient(timeout=8.0) as client:
+                response = await client.get(
+                    f"{ELEVENLABS_BASE_URL}/v1/voices",
+                    headers={"xi-api-key": ELEVENLABS_API_KEY, "Accept": "application/json"},
+                )
+            if response.status_code == 200:
+                voices = response.json().get("voices") or []
+                _ELEVENLABS_NAME_CACHE = (now, voices)
+        except Exception as e:
+            logger.debug(f"ElevenLabs voice auto-assignment unavailable: {e}")
+    aliases = {normalized}
+    if normalized == "vixenbmw":
+        aliases.add("vixen")
+    for voice in voices:
+        voice_name = "".join(ch for ch in str(voice.get("name", "")).lower() if ch.isalnum())
+        if voice_name in aliases or any(alias in voice_name for alias in aliases):
+            return str(voice.get("voice_id") or current)
+    return current
+
+
 async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
     """Public helper to resolve the effective voice config for a robot id."""
     async with aiosqlite.connect(DB_PATH) as db:
@@ -2494,6 +2924,16 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
                     if row:
                         character_name = row["name"]
 
+        async with db.execute("SELECT greeting_phrases FROM devices WHERE id = ?", (robot_id,)) as c:
+            device_row = await c.fetchone()
+        greeting_phrases = []
+        if device_row and device_row["greeting_phrases"]:
+            try:
+                greeting_phrases = [str(p) for p in _json.loads(device_row["greeting_phrases"]) if str(p).strip()]
+            except Exception:
+                greeting_phrases = []
+        if stack_dict:
+            stack_dict["tts_voice"] = await _auto_elevenlabs_voice(character_name or character_id, stack_dict.get("tts_voice"))
         voice_stack = VoiceStack(**stack_dict) if stack_dict else None
         return RobotVoiceConfig(
             character_id=character_id,
@@ -2501,6 +2941,7 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
             system_prompt=system_prompt,
             voice_stack_id=voice_stack.id if voice_stack else None,
             voice_stack=voice_stack,
+            greeting_phrases=greeting_phrases,
         )
 
 
@@ -2594,6 +3035,260 @@ async def delete_voice_stack(stack_id: str):
     return {"ok": True}
 
 
+# =============================================================================
+# TTS VOICE CATALOG
+# =============================================================================
+# These endpoints let the dashboard populate its voice selector with the real
+# set of available voices per provider. ElevenLabs is fetched live from the
+# ElevenLabs REST API (using ELEVENLABS_API_KEY); Kokoro is served from a
+# curated static list (or proxied from a local Kokoro server if KOKORO_BASE_URL
+# is set). Both endpoints are public on the scheduler and require no auth —
+# the ElevenLabs key is only used server-side.
+
+class TtsVoice(BaseModel):
+    id: str
+    name: str
+    language: Optional[str] = None
+    gender: Optional[str] = None
+    description: Optional[str] = None
+    preview_url: Optional[str] = None
+    category: Optional[str] = None
+    labels: Optional[dict] = None
+
+
+class TtsVoiceList(BaseModel):
+    provider: str
+    source: str  # "api", "static", or "proxy"
+    count: int
+    voices: List[TtsVoice]
+    warning: Optional[str] = None
+
+
+# Canonical Kokoro-82M voice list. The id is the value written into
+# voice_stacks.tts_voice; name is what the dashboard shows in the dropdown.
+# Sources: https://huggingface.co/hexgrad/Kokoro-82M and the Kokoro repo
+# voices.json manifest (v1.0). Grouped by language for the dropdown label.
+KOKORO_STATIC_VOICES: List[dict] = [
+    # American English
+    {"id": "af_heart",   "name": "Heart (American English · Female)",   "language": "en-US", "gender": "female"},
+    {"id": "af_bella",   "name": "Bella (American English · Female)",   "language": "en-US", "gender": "female"},
+    {"id": "af_nicole",  "name": "Nicole (American English · Female)",  "language": "en-US", "gender": "female"},
+    {"id": "af_sarah",   "name": "Sarah (American English · Female)",   "language": "en-US", "gender": "female"},
+    {"id": "af_sky",     "name": "Sky (American English · Female)",     "language": "en-US", "gender": "female"},
+    {"id": "am_adam",    "name": "Adam (American English · Male)",      "language": "en-US", "gender": "male"},
+    {"id": "am_michael", "name": "Michael (American English · Male)",   "language": "en-US", "gender": "male"},
+    # British English
+    {"id": "bf_emma",    "name": "Emma (British English · Female)",     "language": "en-GB", "gender": "female"},
+    {"id": "bf_isabella","name": "Isabella (British English · Female)", "language": "en-GB", "gender": "female"},
+    {"id": "bm_george",  "name": "George (British English · Male)",     "language": "en-GB", "gender": "male"},
+    {"id": "bm_lewis",   "name": "Lewis (British English · Male)",      "language": "en-GB", "gender": "male"},
+    # Spanish
+    {"id": "ef_dora",    "name": "Dora (Spanish · Female)",             "language": "es",    "gender": "female"},
+    {"id": "em_alex",    "name": "Alex (Spanish · Male)",               "language": "es",    "gender": "male"},
+    {"id": "em_santa",   "name": "Santa (Spanish · Male)",              "language": "es",    "gender": "male"},
+    # French
+    {"id": "ff_siwis",   "name": "Siwis (French · Female)",             "language": "fr",    "gender": "female"},
+    # Hindi
+    {"id": "hf_alpha",   "name": "Alpha (Hindi · Female)",              "language": "hi",    "gender": "female"},
+    {"id": "hf_beta",    "name": "Beta (Hindi · Female)",               "language": "hi",    "gender": "female"},
+    {"id": "hm_omega",   "name": "Omega (Hindi · Male)",                "language": "hi",    "gender": "male"},
+    {"id": "hm_psi",     "name": "Psi (Hindi · Male)",                  "language": "hi",    "gender": "male"},
+    # Italian
+    {"id": "if_sara",    "name": "Sara (Italian · Female)",             "language": "it",    "gender": "female"},
+    {"id": "im_nicola",  "name": "Nicola (Italian · Male)",             "language": "it",    "gender": "male"},
+    # Japanese
+    {"id": "jf_alpha",   "name": "Alpha (Japanese · Female)",           "language": "ja",    "gender": "female"},
+    {"id": "jf_gongitsune","name": "Gongitsune (Japanese · Female)",    "language": "ja",    "gender": "female"},
+    {"id": "jf_nezumi",  "name": "Nezumi (Japanese · Female)",          "language": "ja",    "gender": "female"},
+    {"id": "jf_tebukuro","name": "Tebukuro (Japanese · Female)",        "language": "ja",    "gender": "female"},
+    {"id": "jm_kumo",    "name": "Kumo (Japanese · Male)",              "language": "ja",    "gender": "male"},
+    # Brazilian Portuguese
+    {"id": "pf_dora",    "name": "Dora (Brazilian Portuguese · Female)","language": "pt-BR", "gender": "female"},
+    {"id": "pm_alex",    "name": "Alex (Brazilian Portuguese · Male)",  "language": "pt-BR", "gender": "male"},
+    {"id": "pm_santa",   "name": "Santa (Brazilian Portuguese · Male)", "language": "pt-BR", "gender": "male"},
+    # Mandarin Chinese
+    {"id": "zf_xiaobei", "name": "Xiaobei (Mandarin · Female)",         "language": "zh",    "gender": "female"},
+    {"id": "zf_xiaoni",  "name": "Xiaoni (Mandarin · Female)",          "language": "zh",    "gender": "female"},
+    {"id": "zf_xiaoxiao","name": "Xiaoxiao (Mandarin · Female)",        "language": "zh",    "gender": "female"},
+    {"id": "zf_xiaoyi",  "name": "Xiaoyi (Mandarin · Female)",          "language": "zh",    "gender": "female"},
+    {"id": "zm_yunjian", "name": "Yunjian (Mandarin · Male)",           "language": "zh",    "gender": "male"},
+    {"id": "zm_yunxi",   "name": "Yunxi (Mandarin · Male)",             "language": "zh",    "gender": "male"},
+    {"id": "zm_yunyang", "name": "Yunyang (Mandarin · Male)",           "language": "zh",    "gender": "male"},
+    {"id": "zm_yunze",   "name": "Yunze (Mandarin · Male)",             "language": "zh",    "gender": "male"},
+]
+
+
+def _kokoro_static_payload() -> TtsVoiceList:
+    voices = [TtsVoice(**v) for v in KOKORO_STATIC_VOICES]
+    return TtsVoiceList(provider="kokoro", source="static", count=len(voices), voices=voices)
+
+
+def _normalize_elevenlabs_voices(raw: dict) -> List[TtsVoice]:
+    """Translate ElevenLabs' /v1/voices response into our TtsVoice shape."""
+    out: List[TtsVoice] = []
+    for v in (raw.get("voices") or []):
+        labels = v.get("labels") or {}
+        # Build a friendly display name. ElevenLabs' "name" is usually the
+        # human label (e.g. "Rachel"); we suffix the category so it's obvious
+        # whether it's premade/cloned/etc.
+        category = v.get("category") or labels.get("category") or ""
+        desc_parts = []
+        if labels.get("accent"):        desc_parts.append(str(labels["accent"]))
+        if labels.get("gender"):        desc_parts.append(str(labels["gender"]).lower())
+        if labels.get("age"):           desc_parts.append(str(labels["age"]).lower())
+        if labels.get("use_case"):      desc_parts.append("use: " + str(labels["use_case"]))
+        if labels.get("descriptive"):   desc_parts.append(str(labels["descriptive"]))
+        description = ", ".join([p for p in desc_parts if p])
+        preview = v.get("preview_url") or ""
+        out.append(TtsVoice(
+            id=str(v.get("voice_id") or ""),
+            name=str(v.get("name") or v.get("voice_id") or "voice"),
+            language=labels.get("language") or labels.get("accent") or None,
+            gender=labels.get("gender") or None,
+            description=description or None,
+            preview_url=preview or None,
+            category=str(category) if category else None,
+            labels=labels or None,
+        ))
+    # Sort: by category then by name for a stable, predictable dropdown order.
+    out.sort(key=lambda x: ((x.category or ""), (x.name or "").lower()))
+    return out
+
+
+async def _fetch_elevenlabs_voices() -> TtsVoiceList:
+    """Call the ElevenLabs /v1/voices endpoint and normalize the result.
+
+    On any failure (missing key, network error, non-2xx) we surface a clear
+    warning alongside an empty list so the dashboard can show the error in
+    the picker rather than silently showing zero voices."""
+    if not ELEVENLABS_API_KEY:
+        return TtsVoiceList(
+            provider="elevenlabs",
+            source="api",
+            count=0,
+            voices=[],
+            warning=(
+                "ELEVENLABS_API_KEY is not set on the scheduler — set it in the "
+                "scheduler's environment to fetch the live voice list."
+            ),
+        )
+    url = f"{ELEVENLABS_BASE_URL}/v1/voices"
+    headers = {"xi-api-key": ELEVENLABS_API_KEY, "Accept": "application/json"}
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            r = await client.get(url, headers=headers)
+    except Exception as e:
+        return TtsVoiceList(
+            provider="elevenlabs",
+            source="api",
+            count=0,
+            voices=[],
+            warning=f"Could not reach ElevenLabs: {e}",
+        )
+    if r.status_code != 200:
+        # Try to extract a useful message from the response body.
+        msg = (r.text or "").strip()[:200]
+        return TtsVoiceList(
+            provider="elevenlabs",
+            source="api",
+            count=0,
+            voices=[],
+            warning=f"ElevenLabs returned {r.status_code}: {msg or 'no body'}",
+        )
+    try:
+        payload = r.json()
+    except Exception as e:
+        return TtsVoiceList(
+            provider="elevenlabs",
+            source="api",
+            count=0,
+            voices=[],
+            warning=f"ElevenLabs returned non-JSON body: {e}",
+        )
+    voices = _normalize_elevenlabs_voices(payload)
+    return TtsVoiceList(provider="elevenlabs", source="api", count=len(voices), voices=voices)
+
+
+async def _fetch_kokoro_voices() -> TtsVoiceList:
+    """Return the Kokoro voice catalog.
+
+    If KOKORO_BASE_URL is set we proxy to that server's /v1/audio/voices
+    (or whatever path it exposes) and adapt the result. Otherwise we serve
+    the curated static list so the dropdown is always populated."""
+    if not KOKORO_BASE_URL:
+        return _kokoro_static_payload()
+    url = f"{KOKORO_BASE_URL}/v1/audio/voices"
+    try:
+        async with httpx.AsyncClient(timeout=6.0) as client:
+            r = await client.get(url)
+        if r.status_code != 200:
+            warning = f"Kokoro server returned {r.status_code}; falling back to static list"
+            fallback = _kokoro_static_payload()
+            return TtsVoiceList(
+                provider=fallback.provider,
+                source="static",
+                count=fallback.count,
+                voices=fallback.voices,
+                warning=warning,
+            )
+        data = r.json()
+        # Kokoro's API shape varies by server; be permissive.
+        raw_list = data.get("voices") if isinstance(data, dict) else data
+        if not isinstance(raw_list, list):
+            raw_list = []
+        voices: List[TtsVoice] = []
+        for v in raw_list:
+            if isinstance(v, str):
+                voices.append(TtsVoice(id=v, name=v))
+            elif isinstance(v, dict):
+                voices.append(TtsVoice(
+                    id=str(v.get("id") or v.get("voice_id") or v.get("name") or ""),
+                    name=str(v.get("name") or v.get("id") or v.get("voice_id") or ""),
+                    language=v.get("language") or v.get("lang"),
+                    gender=v.get("gender"),
+                ))
+        if not voices:
+            fallback = _kokoro_static_payload()
+            return TtsVoiceList(
+                provider=fallback.provider,
+                source="static",
+                count=fallback.count,
+                voices=fallback.voices,
+                warning="Kokoro server returned no voices; falling back to static list",
+            )
+        return TtsVoiceList(provider="kokoro", source="proxy", count=len(voices), voices=voices)
+    except Exception as e:
+        fallback = _kokoro_static_payload()
+        return TtsVoiceList(
+            provider=fallback.provider,
+            source="static",
+            count=fallback.count,
+            voices=fallback.voices,
+            warning=f"Could not reach Kokoro server ({KOKORO_BASE_URL}): {e}",
+        )
+
+
+@app.get("/api/voices/elevenlabs", response_model=TtsVoiceList)
+async def list_elevenlabs_voices():
+    """Return the catalog of ElevenLabs voices for the dashboard picker.
+
+    Proxies the call to ElevenLabs' /v1/voices endpoint using the scheduler's
+    ELEVENLABS_API_KEY env var. Returns a TtsVoiceList with a `warning` field
+    if the key is missing or the upstream call fails — the dashboard surfaces
+    the warning inside the picker so the operator knows what to fix."""
+    return await _fetch_elevenlabs_voices()
+
+
+@app.get("/api/voices/kokoro", response_model=TtsVoiceList)
+async def list_kokoro_voices():
+    """Return the catalog of Kokoro voices for the dashboard picker.
+
+    Served from a curated static list of the canonical Kokoro-82M voices.
+    If KOKORO_BASE_URL is set we proxy to that local server's voices endpoint
+    and surface the live set instead; the static list is the fallback."""
+    return await _fetch_kokoro_voices()
+
+
 @app.get("/api/character-presets", response_model=List[CharacterPreset])
 async def list_character_presets():
     async with aiosqlite.connect(DB_PATH) as db:
@@ -2762,13 +3457,70 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
     Returns trigger_count, sessions_total, avg_latency_ms, drop_rate, drops and
     an end_reason breakdown; None if the robot does not exist."""
     async with db.execute(
-        "SELECT trigger_count, name FROM robots WHERE id = ?", (robot_id,)
+        "SELECT trigger_count, name, status, current_session_id, connected_server_id FROM robots WHERE id = ?", (robot_id,)
     ) as c:
         robot = await c.fetchone()
     if not robot:
         return None
     trigger_count = robot["trigger_count"] or 0
 
+    async with db.execute(
+        "SELECT status, production_mode, last_heartbeat FROM devices WHERE id = ?", (robot_id,)
+    ) as c:
+        device = await c.fetchone()
+    session = None
+    if robot["current_session_id"]:
+        async with db.execute(
+            "SELECT started_at, last_activity_at, ended_at FROM sessions WHERE id = ?",
+            (robot["current_session_id"],),
+        ) as c:
+            session = await c.fetchone()
+
+    now = datetime.utcnow()
+    session_age = None
+    activity_age = None
+    if session:
+        try:
+            session_age = max(0, int((now - datetime.fromisoformat(session["started_at"])).total_seconds()))
+            activity_age = max(0, int((now - datetime.fromisoformat(session["last_activity_at"] or session["started_at"])).total_seconds()))
+        except (TypeError, ValueError):
+            pass
+    heartbeat_age = None
+    if device and device["last_heartbeat"]:
+        try:
+            heartbeat_age = max(0, int((now - datetime.fromisoformat(device["last_heartbeat"])).total_seconds()))
+        except (TypeError, ValueError):
+            pass
+
+    server_status = None
+    if robot["connected_server_id"]:
+        async with db.execute(
+            "SELECT status FROM livekit_servers WHERE id = ?", (robot["connected_server_id"],)
+        ) as c:
+            server_row = await c.fetchone()
+        server_status = server_row["status"] if server_row else None
+
+    readiness_code = "ready"
+    readiness_message = "ready for motion trigger"
+    if not device:
+        readiness_code, readiness_message = "device_missing", "no enrolled device heartbeat"
+    elif not await get_production_mode():
+        readiness_code, readiness_message = "production_off", "global production mode is off"
+    elif not device["production_mode"]:
+        readiness_code, readiness_message = "robot_production_off", "robot production mode is off"
+    elif heartbeat_age is None or heartbeat_age > 30:
+        readiness_code, readiness_message = "heartbeat_stale", f"robot heartbeat is {heartbeat_age or 'unknown'}s old"
+    elif robot["connected_server_id"] and server_status != "online":
+        readiness_code, readiness_message = "server_unavailable", f"LiveKit server {robot['connected_server_id']} is {server_status or 'missing'}"
+    elif not robot["current_session_id"]:
+        readiness_code, readiness_message = "ready", "ready for motion trigger"
+    elif robot["status"] == "connecting" and session_age is not None and session_age > 30:
+        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; recover robot"
+    elif activity_age is not None and activity_age > 180:
+        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; recover robot"
+    else:
+        readiness_code, readiness_message = "in_session", "conversation session is active"
+
     # Pull the device's freshest known LAN address (heartbeat > enrollment) so
     # the dashboard can reach the robot directly for e.g. the vision overlay
     # feed, which the scheduler doesn't proxy.
@@ -2819,6 +3571,17 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         "drop_rate": drop_rate,
         "drops": drops,
         "end_reasons": end_reasons,
+        "status": robot["status"],
+        "current_session_id": robot["current_session_id"],
+        "connected_server_id": robot["connected_server_id"],
+        "server_status": server_status,
+        "session_age_seconds": session_age,
+        "session_activity_age_seconds": activity_age,
+        "heartbeat_age_seconds": heartbeat_age,
+        "device_status": device["status"] if device else None,
+        "production_mode": bool(device["production_mode"]) if device else False,
+        "readiness_code": readiness_code,
+        "readiness_message": readiness_message,
     }
 
 @app.get("/api/robots/{robot_id}/telemetry")
@@ -2937,6 +3700,7 @@ async def dashboard():
                     const newDevice = ref({ name: '', tailscale_ip: '', lan_ip: '', motor_server_url: '', character_id: '', livekit_url: '', video_device: 'auto', audio_device: 'default', notes: '' });
                     const rotatedToken = ref(null);
                     const preview = ref({ robot: null, active: false, url: null, token: null, room: null, keepalive: null });
+                    const simulation = ref({ robotId: null, busy: false });
                     const deviceInventory = ref({});
                     const showLiveKitConfig = ref(false);
                     const livekitForm = ref({ url: '', api_key: '', api_secret: '' });
@@ -2948,7 +3712,7 @@ async def dashboard():
                     const editingCharacter = ref(null);
                     const voiceStackForm = ref({
                         id: '', name: '', stt_provider: 'speaches', stt_model: 'Systran/faster-whisper-small', stt_language: 'en',
-                        llm_provider: 'ollama', llm_model: 'gemma4:e4b', tts_provider: 'elevenlabs',
+                        llm_provider: 'ollama', llm_model: 'gemma3:27b', tts_provider: 'elevenlabs',
                         tts_voice: '21m00Tcm4TlvDq8ikWAM', tts_language: 'en',
                         allow_interruptions: true, min_endpointing_delay: 0.7, max_turns: 20, wake_word_enabled: false,
                     });
@@ -3060,12 +3824,14 @@ async def dashboard():
                     const toggleProductionMode = async () => {
                         try {
                             const next = !settings.value.production_mode;
-                            await fetch('/api/settings', {
+                            const response = await fetch('/api/settings', {
                                 method: 'PUT',
                                 headers: {'Content-Type': 'application/json'},
                                 body: JSON.stringify({ production_mode: next }),
                             });
+                            if (!response.ok) throw new Error(`HTTP ${response.status}`);
                             settings.value.production_mode = next;
+                            await fetchData();
                         } catch (e) {
                             alert('Failed to toggle production mode: ' + e.message);
                         }
@@ -3147,6 +3913,35 @@ async def dashboard():
                         preview.value = { robot: null, active: false, url: null, token: null, room: null, keepalive: null };
                     };
 
+                    const simulateTrigger = async (robot) => {
+                        if (!settings.value.production_mode || simulation.value.busy) return;
+                        simulation.value = { robotId: robot.id, busy: true };
+                        try {
+                            const response = await fetch(`/api/robots/${robot.id}/simulate-trigger`, { method: 'POST' });
+                            const result = await response.json();
+                            if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+                            if (!result.queued) {
+                                alert('Trigger not queued: ' + (result.reason || 'unknown'));
+                            }
+                            await fetchData();
+                        } catch (e) {
+                            alert('Failed to simulate motion: ' + e.message);
+                        } finally {
+                            simulation.value = { robotId: null, busy: false };
+                        }
+                    };
+
+                    const stopConversation = async (robot) => {
+                        try {
+                            const response = await fetch(`/api/robots/${robot.id}/simulate-stop`, { method: 'POST' });
+                            const result = await response.json();
+                            if (!response.ok) throw new Error(result.detail || `HTTP ${response.status}`);
+                            await fetchData();
+                        } catch (e) {
+                            alert('Failed to stop conversation: ' + e.message);
+                        }
+                    };
+
                     const connectLiveKitPreview = async (url, token) => {
                         const { Room } = LiveKitClient;
                         const room = new Room({ adaptiveStream: true });
@@ -3297,7 +4092,7 @@ async def dashboard():
                             editingVoiceStack.value = null;
                             voiceStackForm.value = {
                                 id: '', name: '', stt_provider: 'speaches', stt_model: 'Systran/faster-whisper-small', stt_language: 'en',
-                                llm_provider: 'ollama', llm_model: 'gemma4:e4b', tts_provider: 'elevenlabs',
+                                llm_provider: 'ollama', llm_model: 'gemma3:27b', tts_provider: 'elevenlabs',
                                 tts_voice: '21m00Tcm4TlvDq8ikWAM', tts_language: 'en',
                                 allow_interruptions: true, min_endpointing_delay: 0.7, max_turns: 20, wake_word_enabled: false,
                             };
@@ -3383,7 +4178,7 @@ async def dashboard():
 
                     return {
                         robots, servers, sessions, stats, connected, serverMetrics,
-                        devices, settings, livekit, showAddDevice, showDevices, newDevice, rotatedToken,
+                        devices, settings, livekit, showAddDevice, showDevices, newDevice, rotatedToken, simulation,
                         showLiveKitConfig, livekitForm, preview, deviceInventory,
                         voiceStacks, characterPresets, showVoiceStackForm, showCharacterForm,
                         editingVoiceStack, editingCharacter, voiceStackForm, characterForm,
@@ -3391,7 +4186,7 @@ async def dashboard():
                         toggleProductionMode, rotateEnrollmentToken,
                         submitNewDevice, deleteDevice, rotateDeviceToken, dismissRotatedToken,
                         joinConversation, saveLiveKitConfig, openLiveKitConfig,
-                        startPreview, stopPreview, updateDeviceMedia,
+                        startPreview, stopPreview, simulateTrigger, stopConversation, updateDeviceMedia,
                         openVoiceStackForm, saveVoiceStack, deleteVoiceStack,
                         openCharacterForm, saveCharacter, deleteCharacter,
                         assignRobotCharacter, stackName, characterName,
@@ -3689,6 +4484,20 @@ async def dashboard():
                                                     class="w-full px-2 py-1 rounded text-xs">
                                                 {{ preview.active && preview.robot?.id === robot.id ? 'Preview Active' : 'Start Preview' }}
                                             </button>
+                                            <div class="grid grid-cols-2 gap-2">
+                                                <button @click="simulateTrigger(robot)"
+                                                        :disabled="!settings.production_mode || simulation.busy || robot.status === 'connecting' || robot.status === 'running'"
+                                                        :class="settings.production_mode && !simulation.busy && robot.status !== 'connecting' && robot.status !== 'running' ? 'bg-amber-600 hover:bg-amber-500' : 'bg-gray-700 cursor-not-allowed'"
+                                                        class="px-2 py-1 rounded text-xs">
+                                                    {{ simulation.robotId === robot.id ? 'Triggering…' : 'Simulate Motion' }}
+                                                </button>
+                                                <button @click="stopConversation(robot)"
+                                                        :disabled="robot.status !== 'connecting' && robot.status !== 'running'"
+                                                        :class="robot.status === 'connecting' || robot.status === 'running' ? 'bg-red-600 hover:bg-red-500' : 'bg-gray-700 cursor-not-allowed'"
+                                                        class="px-2 py-1 rounded text-xs">
+                                                    Stop Conversation
+                                                </button>
+                                            </div>
                                             <button v-if="preview.active && preview.robot?.id === robot.id"
                                                     @click="stopPreview"
                                                     class="w-full px-2 py-1 bg-red-600 hover:bg-red-700 rounded text-xs">