infinicode 2.8.102 → 2.8.104

package/packages/robopark/scheduler/main.py

@@ -3192,6 +3192,93 @@ PIPELINE_STAGES = (
 )
 PIPELINE_STATUSES = {"pending", "running", "ok", "failed", "blocked", "skipped"}
 
+PIPELINE_STAGE_LABELS = {
+    "robot_online": "Robot online",
+    "camera_ready": "Camera detected",
+    "microphone_ready": "Microphone detected",
+    "speaker_ready": "Speaker detected",
+    "motion_detected": "Waiting for motion",
+    "scheduler_session": "Allocating session",
+    "livekit_join": "Joining LiveKit",
+    "camera_published": "Publishing camera",
+    "microphone_published": "Publishing microphone",
+    "voice_worker": "Starting voice worker",
+    "stt_listening": "Listening to visitor",
+    "llm_response": "Preparing response",
+    "tts_subscribed": "Preparing robot voice",
+    "playback_started": "Speaking through robot",
+    "motor_sequence": "Running motor sequence",
+    "session_ended": "Closing session",
+}
+
+
+def _pipeline_current_state(events: list[dict], *, active: bool,
+                            production_mode: bool, online: bool) -> dict:
+    """Derive one operator-facing live stage from persistent pipeline events."""
+    if not online:
+        return {
+            "stage": "robot_online", "status": "blocked",
+            "label": PIPELINE_STAGE_LABELS["robot_online"],
+            "message": "Robot heartbeat is stale or missing", "since": None,
+        }
+    if not active:
+        return {
+            "stage": "motion_detected",
+            "status": "waiting" if production_mode else "paused",
+            "label": "Armed - waiting for motion" if production_mode else "Production paused",
+            "message": "Motion detection is armed" if production_mode else "Enable production mode to arm this robot",
+            "since": None,
+        }
+
+    scoped = [event for event in events if event.get("session_id")]
+    for event in reversed(scoped):
+        if event.get("status") in {"failed", "blocked"}:
+            return {
+                "stage": event["stage"], "status": event["status"],
+                "label": PIPELINE_STAGE_LABELS.get(event["stage"], event["stage"]),
+                "message": event.get("message") or "Pipeline requires attention",
+                "since": event.get("timestamp"),
+            }
+
+    conversational = {
+        "voice_worker", "stt_listening", "llm_response", "tts_subscribed",
+        "playback_started", "motor_sequence",
+    }
+    latest = next((event for event in reversed(scoped) if event.get("stage") in conversational), None)
+    if latest:
+        stage = latest["stage"]
+        status = latest.get("status") or "running"
+        if status in {"ok", "skipped"}:
+            stage = {
+                "voice_worker": "stt_listening",
+                "stt_listening": "llm_response",
+                "llm_response": "tts_subscribed",
+                "tts_subscribed": "playback_started",
+                "playback_started": "stt_listening",
+                "motor_sequence": "stt_listening",
+            }.get(stage, stage)
+            status = "active"
+        return {
+            "stage": stage, "status": status,
+            "label": PIPELINE_STAGE_LABELS.get(stage, stage),
+            "message": latest.get("message") or PIPELINE_STAGE_LABELS.get(stage, stage),
+            "since": latest.get("timestamp"),
+        }
+
+    startup = (
+        "scheduler_session", "livekit_join", "camera_published",
+        "microphone_published", "voice_worker",
+    )
+    completed = {event.get("stage") for event in scoped if event.get("status") in {"ok", "skipped"}}
+    stage = next((candidate for candidate in startup if candidate not in completed), "voice_worker")
+    latest_startup = next((event for event in reversed(scoped) if event.get("stage") in startup), None)
+    return {
+        "stage": stage, "status": "active",
+        "label": PIPELINE_STAGE_LABELS.get(stage, stage),
+        "message": (latest_startup or {}).get("message") or "Production conversation is starting",
+        "since": (latest_startup or {}).get("timestamp"),
+    }
+
 async def _insert_pipeline_event(device_id: str, payload: PipelineEventPayload) -> dict:
     if payload.stage not in PIPELINE_STAGES:
         raise HTTPException(422, f"Unknown pipeline stage: {payload.stage}")
@@ -3286,16 +3373,29 @@ async def robot_pipeline_status(robot_id: str, limit: int = 80):
         blockers.append("Microphone inventory has not been reported")
     if not prereqs["speaker_ready"]:
         blockers.append("Speaker inventory has not been reported")
+    active = bool(latest_session and not latest_session["ended_at"])
+    active_session_id = latest_session["id"] if active else None
+    current_events = [
+        event for event in events
+        if not active_session_id or event.get("session_id") == active_session_id
+    ]
+    current_stage = _pipeline_current_state(
+        current_events,
+        active=active,
+        production_mode=bool(device["production_mode"]),
+        online=prereqs["robot_online"],
+    )
     return {
         "robot_id": device_id,
         "robot_name": device["name"],
-        "overall": "blocked" if blockers else ("running" if latest_session and not latest_session["ended_at"] else "ready"),
+        "overall": "blocked" if blockers else ("running" if active else "ready"),
         "blockers": list(dict.fromkeys(blockers)),
         "prerequisites": prereqs,
         "telemetry": telemetry,
         "latest_session": dict(latest_session) if latest_session else None,
         "events": events,
         "stages": list(PIPELINE_STAGES),
+        "current_stage": current_stage,
     }
 
 @app.get("/api/robots/{robot_id}/pipeline-history")
@@ -4031,6 +4131,22 @@ async def test_robot_motor(robot_id: str, motor_id: str, duration_ms: int = 300)
     })
     return {"queued": True, "request_id": request_id, "device_id": model.id}
 
+@app.post("/api/robots/{robot_id}/motors/discover")
+async def discover_robot_motors(robot_id: str):
+    """Import relays already registered by the robot-local motor server.
+
+    This is read-only on the robot. It never scans or pulses unregistered GPIO.
+    The dashboard validates and persists the returned registry before testing.
+    """
+    device = await _resolve_device_by_id_or_name(robot_id)
+    model = _device_row_to_model(device)
+    if not model.motor_server_url:
+        raise HTTPException(409, "Robot has no motor_server_url")
+    request_id = await _queue_shell_request_async(model.id, "motor_discover", "motor_server", {
+        "motor_server_url": model.motor_server_url,
+    })
+    return {"queued": True, "request_id": request_id, "device_id": model.id}
+
 @app.post("/api/robots/{robot_id}/motors/test-all")
 async def test_all_robot_motors(robot_id: str, duration_ms: int = 300, pause_ms: int = 200):
     device = await _resolve_device_by_id_or_name(robot_id)
@@ -5170,13 +5286,20 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
 
     device_inventory = parse_json_field(device["device_inventory"], {}) if device else {}
     supervisor_status = parse_json_field(device["supervisor_status"], []) if device else []
-    session = None
-    if robot["current_session_id"]:
+    session = None
+    current_pipeline_events = []
+    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()
+        ) as c:
+            session = await c.fetchone()
+        async with db.execute(
+            "SELECT * FROM pipeline_events WHERE robot_id = ? AND session_id = ? "
+            "ORDER BY timestamp, id",
+            (robot_id, robot["current_session_id"]),
+        ) as c:
+            current_pipeline_events = [dict(row) for row in await c.fetchall()]
 
     now = datetime.utcnow()
     session_age = None
@@ -5259,8 +5382,14 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         (robot_id,),
     ) as c:
         end_reasons = {r["end_reason"]: r["n"] for r in await c.fetchall()}
-    drops = sum(n for reason, n in end_reasons.items() if reason in ABNORMAL_END_REASONS)
-    drop_rate = round(drops / sessions_total, 4) if sessions_total else 0.0
+    drops = sum(n for reason, n in end_reasons.items() if reason in ABNORMAL_END_REASONS)
+    drop_rate = round(drops / sessions_total, 4) if sessions_total else 0.0
+    current_stage = _pipeline_current_state(
+        current_pipeline_events,
+        active=bool(robot["current_session_id"] and session and not session["ended_at"]),
+        production_mode=bool(device["production_mode"]) if device else False,
+        online=heartbeat_age is not None and heartbeat_age <= 30,
+    )
 
     return {
         "robot_id": robot_id,
@@ -5291,9 +5420,13 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         "supervisor_status": supervisor_status,
         "supervisor_status_at": device["supervisor_status_at"] if device else None,
         "production_mode": bool(device["production_mode"]) if device else False,
-        "readiness_code": readiness_code,
-        "readiness_message": readiness_message,
-    }
+        "readiness_code": readiness_code,
+        "readiness_message": readiness_message,
+        "current_stage": current_stage,
+        "current_stage_id": current_stage["stage"],
+        "current_stage_label": current_stage["label"],
+        "current_stage_status": current_stage["status"],
+    }
 
 @app.get("/api/robots/{robot_id}/telemetry")
 async def robot_telemetry(robot_id: str):

package/packages/robopark/scheduler/preview_agent.py

@@ -1303,7 +1303,7 @@ class LiveKitPublisher:
         self._echo_mic_floor = 0.0
         self._barge_in_candidate_frames = 0
         self._speaker_echo_tail = max(
-            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "700")) / 1000.0, 2.0)
+            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "350")) / 1000.0, 2.0)
         )
         self._adaptive_barge_in = str(
             os.getenv("ROBOPARK_ADAPTIVE_BARGE_IN", "true")
@@ -1553,7 +1553,7 @@ class LiveKitPublisher:
         import threading
         write_queue: "queue.Queue[Optional[bytes]]" = queue.Queue()
         written_frames = [0]
-        PREBUFFER_CHUNKS = 5
+        PREBUFFER_CHUNKS = 3
         stream_failed = threading.Event()
         playback_reported = threading.Event()
         event_loop = asyncio.get_running_loop()

package/packages/robopark/scheduler/robot_supervisor.py

@@ -427,6 +427,8 @@ def _handle_shell_command(identity, cmd: dict) -> None:
         result = _run_shell_command(params.get("name", ""), params)
     elif kind == "speaker_test":
         result = _speaker_roundtrip_test(params)
+    elif kind == "motor_discover":
+        result = _discover_motor_registry(params)
     elif kind == "motor_sequence":
         result = _run_motor_sequence(params)
     else:
@@ -434,6 +436,45 @@ def _handle_shell_command(identity, cmd: dict) -> None:
     _post_supervisor_output(identity, kind, service, result, request_id)
 
 
+def _discover_motor_registry(params: dict) -> dict:
+    """Read the robot-local motor registry without touching any GPIO output."""
+    import httpx
+    import re
+
+    base = str(params.get("motor_server_url") or "http://127.0.0.1:8001").rstrip("/")
+    if not (base.startswith("http://127.0.0.1:") or base.startswith("http://localhost:")):
+        return {"ok": False, "error": "motor server must be robot-local"}
+    try:
+        with httpx.Client(timeout=5.0) as client:
+            response = client.get(f"{base}/list-motors")
+            response.raise_for_status()
+            raw_motors = response.json().get("motors", [])
+        registry, used_ids, used_gpios = [], set(), set()
+        for index, raw in enumerate(raw_motors[:32]):
+            gpio = int(raw.get("gpio", -1))
+            if gpio < 2 or gpio > 27 or gpio in used_gpios:
+                continue
+            name = str(raw.get("name") or f"Relay {index + 1}").strip()[:60]
+            base_id = re.sub(r"[^a-z0-9_-]+", "-", name.lower()).strip("-") or f"relay-{index + 1}"
+            motor_id, suffix = base_id[:32], 2
+            while motor_id in used_ids:
+                tail = f"-{suffix}"
+                motor_id = f"{base_id[:32-len(tail)]}{tail}"
+                suffix += 1
+            used_ids.add(motor_id)
+            used_gpios.add(gpio)
+            registry.append({
+                "id": motor_id,
+                "name": name,
+                "gpio": gpio,
+                "active_high": bool(raw.get("active_high", True)),
+                "max_duration_ms": 3000,
+            })
+        return {"ok": True, "registry": registry, "count": len(registry), "motor_server_url": base}
+    except Exception as exc:
+        return {"ok": False, "error": f"motor registry discovery failed: {type(exc).__name__}: {exc}"}
+
+
 def _run_motor_sequence(params: dict) -> dict:
     """Run one validated scheduler sequence against the robot-local motor API."""
     import httpx