infinicode 2.8.83 → 2.8.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.83",
+  "version": "2.8.85",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/main.py

@@ -839,10 +839,70 @@ async def broadcast(event_type: str, data: dict):
             ws_clients.remove(client)
 
 # =============================================================================
-# ROBOT ENDPOINTS
-# =============================================================================
-
-@app.get("/api/robots", response_model=List[Robot])
+# ROBOT ENDPOINTS
+# =============================================================================
+
+CONNECTING_SESSION_LEASE_SECONDS = max(
+    15, int(os.getenv("ROBOPARK_CONNECTING_SESSION_LEASE_SECONDS", "45"))
+)
+ACTIVE_SESSION_LEASE_SECONDS = max(
+    CONNECTING_SESSION_LEASE_SECONDS,
+    int(os.getenv("ROBOPARK_ACTIVE_SESSION_LEASE_SECONDS", "180")),
+)
+
+
+async def _reap_robot_session_if_stale(db, robot_id: str, current_session_id: Optional[str],
+                                       robot_status: Optional[str] = None) -> Optional[str]:
+    """Release an invalid or expired session pointer without operator action."""
+    if not current_session_id:
+        return None
+
+    async with db.execute(
+        "SELECT id, started_at, last_activity_at, ended_at FROM sessions WHERE id = ?",
+        (current_session_id,),
+    ) as cursor:
+        session = await cursor.fetchone()
+
+    reason = None
+    if not session:
+        reason = "missing_session"
+    elif session["ended_at"]:
+        reason = "ended_session"
+    else:
+        timestamp = session["last_activity_at"] or session["started_at"]
+        try:
+            activity_age = (datetime.utcnow() - datetime.fromisoformat(timestamp)).total_seconds()
+        except (TypeError, ValueError):
+            activity_age = ACTIVE_SESSION_LEASE_SECONDS + 1
+        lease = (
+            CONNECTING_SESSION_LEASE_SECONDS
+            if robot_status == "connecting"
+            else ACTIVE_SESSION_LEASE_SECONDS
+        )
+        if activity_age >= lease:
+            reason = "stale_connecting" if robot_status == "connecting" else "stale_activity"
+
+    if not reason:
+        return None
+
+    now = datetime.utcnow().isoformat()
+    if session and not session["ended_at"]:
+        await db.execute(
+            "UPDATE sessions SET ended_at = ?, end_reason = ? WHERE id = ? AND ended_at IS NULL",
+            (now, reason, current_session_id),
+        )
+    await db.execute(
+        "UPDATE robots SET status = 'idle', current_session_id = NULL, connected_server_id = NULL "
+        "WHERE id = ? AND current_session_id = ?",
+        (robot_id, current_session_id),
+    )
+    logger.warning(
+        "Automatically released %s session %s for robot %s",
+        reason, current_session_id, robot_id,
+    )
+    return reason
+
+@app.get("/api/robots", response_model=List[Robot])
 async def list_robots():
     """List all robots"""
     async with aiosqlite.connect(DB_PATH) as db:
@@ -909,11 +969,23 @@ async def request_session(robot_id: str,
                     (robot_id, device_row["name"]),
                 )
                 await db.commit()
-                robot = {"id": robot_id, "name": device_row["name"], "status": "idle"}
-            else:
-                raise HTTPException(404, "Robot not found")
-            if robot["status"] != "idle":
-                raise HTTPException(400, f"Robot is {robot['status']}, not idle")
+                robot = {
+                    "id": robot_id,
+                    "name": device_row["name"],
+                    "status": "idle",
+                    "current_session_id": None,
+                }
+            else:
+                raise HTTPException(404, "Robot not found")
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if stale_reason:
+            await db.commit()
+            async with db.execute("SELECT * FROM robots WHERE id = ?", (robot_id,)) as cursor:
+                robot = await cursor.fetchone()
+        if robot["current_session_id"] or robot["status"] != "idle":
+            raise HTTPException(409, f"Robot is {robot['status']}, not idle")
         
         # Find least-loaded online server
         async with db.execute("""
@@ -1046,7 +1118,7 @@ async def simulate_trigger(robot_id: str):
     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,)
+            "SELECT id, current_session_id, status FROM robots WHERE id = ?", (robot_id,)
         ) as c:
             robot = await c.fetchone()
         if not robot:
@@ -1059,11 +1131,14 @@ async def simulate_trigger(robot_id: str):
                 (device["id"], device["name"], device["character_id"]),
             )
             await db.commit()
-            robot = {"id": device["id"], "current_session_id": None}
+            robot = {"id": device["id"], "current_session_id": None, "status": "idle"}
         if not await _effective_device_production_mode(db, robot_id):
             return {"queued": False, "reason": "device_production_mode_off"}
-        if robot["current_session_id"]:
-            return {"queued": False, "reason": "session_active"}
+        stale_reason = await _reap_robot_session_if_stale(
+            db, robot_id, robot["current_session_id"], robot["status"]
+        )
+        if robot["current_session_id"] and not stale_reason:
+            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",
@@ -1072,7 +1147,12 @@ async def simulate_trigger(robot_id: str):
         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"}
+    return {
+        "queued": True,
+        "source": "dashboard",
+        "recovered_stale_session": bool(stale_reason),
+        "recovery_reason": stale_reason,
+    }
 
 @app.post("/api/robots/{robot_id}/simulate-stop")
 async def simulate_stop(robot_id: str):
@@ -1487,14 +1567,31 @@ async def session_joined(session_id: str,
             session = await c.fetchone()
         if not session:
             raise HTTPException(404, "Session not found")
-        if session["joined_at"]:
-            return {
-                "status": "already_joined",
-                "joined_at": session["joined_at"],
-                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
-            }
-        await db.execute("UPDATE sessions SET joined_at = ? WHERE id = ?", (now, session_id))
-        await db.commit()
+        if session["joined_at"]:
+            if not session["ended_at"]:
+                await db.execute(
+                    "UPDATE sessions SET last_activity_at = ? WHERE id = ?",
+                    (now, session_id),
+                )
+                await db.execute(
+                    "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+                    (session["robot_id"], session_id),
+                )
+                await db.commit()
+            return {
+                "status": "already_joined",
+                "joined_at": session["joined_at"],
+                "latency_ms": _session_latency_ms(session["started_at"], session["joined_at"]),
+            }
+        await db.execute(
+            "UPDATE sessions SET joined_at = ?, last_activity_at = ? WHERE id = ?",
+            (now, now, session_id),
+        )
+        await db.execute(
+            "UPDATE robots SET status = 'running' WHERE id = ? AND current_session_id = ?",
+            (session["robot_id"], session_id),
+        )
+        await db.commit()
     latency_ms = _session_latency_ms(session["started_at"], now)
     await broadcast("session_joined", {"session_id": session_id, "latency_ms": latency_ms})
     await _log_history("session", "session", session_id, "joined", "robot", f"latency_ms={latency_ms}")
@@ -1955,19 +2052,38 @@ 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:
+                # Release stale robot session pointers with the same lease rules
+                # used by the trigger path. Failed joins cannot require manual
+                # operator recovery or block an unattended robot indefinitely.
+                async with db.execute(
+                    "SELECT id, status, current_session_id FROM robots WHERE current_session_id IS NOT NULL"
+                ) as c:
+                    session_owners = await c.fetchall()
+                for owner in session_owners:
+                    reason = await _reap_robot_session_if_stale(
+                        db, owner["id"], owner["current_session_id"], owner["status"]
+                    )
+                    if reason:
+                        await broadcast("session_expired", {
+                            "session_id": owner["current_session_id"],
+                            "robot_id": owner["id"],
+                            "reason": reason,
+                        })
+
+                # Reap old orphan rows that are no longer owned by a robot.
+                session_cutoff = (
+                    datetime.utcnow() - timedelta(seconds=ACTIVE_SESSION_LEASE_SECONDS)
+                ).isoformat()
+                async with db.execute(
+                    "SELECT id, robot_id FROM sessions "
+                    "WHERE ended_at IS NULL AND COALESCE(last_activity_at, started_at) < ? "
+                    "AND NOT EXISTS (SELECT 1 FROM robots r WHERE r.current_session_id = sessions.id)",
+                    (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' "
+                        "UPDATE sessions SET ended_at = ?, end_reason = 'stale_orphan' "
                         "WHERE id = ? AND ended_at IS NULL",
                         (datetime.utcnow().isoformat(), session["id"]),
                     )
@@ -1979,7 +2095,7 @@ async def health_checker():
                     await broadcast("session_expired", {
                         "session_id": session["id"],
                         "robot_id": session["robot_id"],
-                        "reason": "silence",
+                            "reason": "stale_orphan",
                     })
 
                 await db.commit()
@@ -4748,10 +4864,10 @@ async def _robot_telemetry(db, robot_id: str) -> Optional[dict]:
         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"
+    elif robot["status"] == "connecting" and session_age is not None and session_age > CONNECTING_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stuck_session", f"joining LiveKit for {session_age}s; automatic recovery pending"
+    elif activity_age is not None and activity_age > ACTIVE_SESSION_LEASE_SECONDS:
+        readiness_code, readiness_message = "stale_session", f"no session activity for {activity_age}s; automatic recovery pending"
     else:
         readiness_code, readiness_message = "in_session", "conversation session is active"
 

package/packages/robopark/scheduler/preview_agent.py

@@ -397,6 +397,10 @@ class PreviewAgent:
         # use the resolved hardware name reported in that same inventory.
         self.audio_capture_device = self.audio_device
         self.audio_output_device = cfg.get("audio_output_device", os.getenv("AUDIO_OUTPUT_DEVICE", "default"))
+        # Keep RoboVision/sounddevice inventory IDs out of PyAudio. Both APIs
+        # number the same ALSA cards differently, so resolve the selected ID
+        # to its hardware name before opening any playback stream.
+        self.audio_playback_device = self.audio_output_device
         self.robovision_url = cfg.get("robovision_url", os.getenv("ROBOVISION_URL", "http://127.0.0.1:5000"))
         self.use_robovision_camera = bool(cfg.get("use_robovision_camera", False))
         self.width = int(cfg.get("video_width", os.getenv("VIDEO_WIDTH", DEFAULT_VIDEO_WIDTH)))
@@ -689,6 +693,16 @@ class PreviewAgent:
             if data.get("audio_output_device") is not None:
                 changed = changed or self.audio_output_device != data["audio_output_device"]
                 self.audio_output_device = data["audio_output_device"]
+                inventory = data.get("device_inventory") or {}
+                selected = str(self.audio_output_device)
+                self.audio_playback_device = next(
+                    (
+                        str(item.get("name"))
+                        for item in inventory.get("audio_output", [])
+                        if str(item.get("id")) == selected and item.get("name")
+                    ),
+                    self.audio_output_device,
+                )
             if changed:
                 await self._sync_robovision_media_config()
         except Exception as e:
@@ -812,7 +826,7 @@ class PreviewAgent:
         self._vision_last_activity = 0.0
         self._remote_session_ended = False
         await self._stop_publisher()
-        await asyncio.to_thread(_play_audio_effect, self.audio_output_device, "disconnect")
+        await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "disconnect")
         self._current_state = PreviewState()
 
     async def _heartbeat_loop(self) -> None:
@@ -865,7 +879,7 @@ class PreviewAgent:
             restore_state = self._current_state if self._publisher else None
             if restore_state:
                 await self._stop_publisher()
-                await asyncio.sleep(0.35)
+                await asyncio.sleep(1.0)
             try:
                 result = await asyncio.to_thread(_speaker_roundtrip_test, request.get("params") or {})
                 result["media_owner_paused"] = bool(restore_state)
@@ -1028,7 +1042,7 @@ class PreviewAgent:
         await asyncio.sleep(0.5)
         # I/O. Camera/mic join and the preset greeting are the critical path.
         asyncio.create_task(
-            asyncio.to_thread(_play_audio_effect, self.audio_output_device, "motion")
+            asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
         )
         try:
             r = await self._session.post(
@@ -1234,7 +1248,7 @@ class LiveKitPublisher:
         # never actually reaching the real speakers. Prefer WASAPI's default output,
         # which is what Windows' own volume mixer/meter is backed by.
         output_device_index = None
-        selected_output = str(self.agent.audio_output_device or "default")
+        selected_output = str(self.agent.audio_playback_device or "default")
         if selected_output.strip().isdigit():
             output_device_index = int(selected_output.strip())
         try:

package/packages/robopark/scheduler/robot_supervisor.py

@@ -578,6 +578,49 @@ def _open_pcm_stream(pa, pyaudio_module, kind: str, device_index: Optional[int],
     )
 
 
+def _linux_aplay_pcm16(raw: bytes, selected_output: str, sample_rate: int,
+                       channels: int = 1) -> tuple[bool, str]:
+    """Play PCM through the same ALSA plughw path proven during Pi setup.
+
+    PortAudio and RoboVision enumerate devices in different index spaces. The
+    inventory name contains the stable ALSA hw tuple, so use it directly and
+    let ALSA's plug layer adapt the cached TTS sample rate/channel count.
+    """
+    import re
+
+    match = re.search(r"hw:(\d+),(\d+)", str(selected_output), re.IGNORECASE)
+    if not match:
+        return False, "selected output has no ALSA hw address"
+    alsa_device = f"plughw:{match.group(1)},{match.group(2)}"
+    command = [
+        "aplay", "-q", "-D", alsa_device, "-t", "raw", "-f", "S16_LE",
+        "-r", str(sample_rate), "-c", str(channels),
+    ]
+    last_error = "aplay failed"
+    # ALSA can retain an exclusive USB handle briefly after the LiveKit
+    # playback stream closes. Retry for a bounded period instead of declaring
+    # a valid device unsupported on the first EBUSY response.
+    for attempt in range(5):
+        if attempt:
+            time.sleep(0.5)
+        try:
+            completed = subprocess.run(
+                command,
+                input=raw,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
+                timeout=max(5.0, len(raw) / max(1, sample_rate * channels * 2) + 3.0),
+                check=False,
+            )
+        except Exception as exc:
+            last_error = f"{type(exc).__name__}: {exc}"
+            continue
+        if completed.returncode == 0:
+            return True, alsa_device
+        last_error = completed.stderr.decode("utf-8", errors="replace").strip() or f"aplay exited {completed.returncode}"
+    return False, f"{alsa_device}: {last_error}"
+
+
 def _speaker_roundtrip_test(params: dict) -> dict:
     """Play a test tone + record the mic simultaneously; return metrics.
 
@@ -618,10 +661,46 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         if dur > 10.0:
             return {"ok": False, "error": "cached TTS audio exceeds the 10 second test limit"}
     n_samples = int(source_rate * dur)
-    if n_samples < 480:
-        return {"ok": False, "error": "duration too short"}
-
-    pa = pyaudio.PyAudio()
+    if n_samples < 480:
+        return {"ok": False, "error": "duration too short"}
+
+    # Cached character voice is output-only. On Linux, bypass PortAudio's
+    # unrelated index space and use the exact ALSA plughw endpoint selected by
+    # RoboVision. This is the same path used by the successful onsite test.
+    if playback_only and mono_pcm is not None and sys.platform.startswith("linux"):
+        t0 = time.monotonic()
+        played, detail = _linux_aplay_pcm16(mono_pcm, str(out_name), source_rate)
+        duration_ms = int((time.monotonic() - t0) * 1000)
+        if not played:
+            return {
+                "ok": False,
+                "error": f"ALSA playback failed: {detail}",
+                "duration_ms": duration_ms,
+                "output_device": str(out_name),
+                "input_device": "not opened (speaker-only test)",
+                "duration": dur,
+            }
+        return {
+            "ok": True,
+            "pass": True,
+            "played": True,
+            "playback_only": True,
+            "mode": mode,
+            "text": params.get("text"),
+            "cache_hit": bool(params.get("cache_hit")),
+            "tts_provider": params.get("tts_provider"),
+            "tts_voice": params.get("tts_voice"),
+            "duration": dur,
+            "duration_ms": duration_ms,
+            "sample_rate": source_rate,
+            "output_sample_rate": source_rate,
+            "output_channels": 1,
+            "output_device": detail,
+            "input_device": "not opened (speaker-only test)",
+            "diagnostic": "cached voice played through the selected ALSA plughw endpoint",
+        }
+
+    pa = pyaudio.PyAudio()
     out_idx = _resolve_audio_device(pa, out_name, "output")
     in_idx = None if playback_only else _resolve_audio_device(pa, in_name, "input")
     def _dev_name(idx):