infinicode 2.8.90 → 2.8.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.90",
+  "version": "2.8.91",
   "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/preview_agent.py

@@ -455,6 +455,9 @@ class PreviewAgent:
         self._vision_session_id: Optional[str] = None
         self._vision_trigger_in_flight = False
         self._speaker_test_in_flight = False
+        # The USB adapter is an exclusive ALSA endpoint. Keep operator tests
+        # and motion cues from racing each other while LiveKit is paused.
+        self._speaker_operation_lock = asyncio.Lock()
         self._vision_hard_deadline: float = 0.0
         self._vision_last_activity: float = 0.0
         self.production_mode = False
@@ -896,18 +899,20 @@ class PreviewAgent:
                 return
             self._speaker_test_in_flight = True
             from robot_supervisor import _speaker_roundtrip_test
-            # LiveKit owns the USB microphone continuously. Release that owner
-            # for an explicit hardware test, then restore the same session.
-            restore_state = self._current_state if self._publisher else None
-            if restore_state:
-                await self._stop_publisher()
-                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)
-            finally:
-                if restore_state and restore_state.active:
-                    await self._start_publisher(restore_state)
+            async with self._speaker_operation_lock:
+                # LiveKit owns the USB microphone and speaker continuously.
+                # Pause it while holding the same lock as the motion cue so
+                # nothing can reopen ALSA before the explicit test starts.
+                restore_state = self._current_state if self._publisher else None
+                if restore_state:
+                    await self._stop_publisher()
+                    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)
+                finally:
+                    if restore_state and restore_state.active:
+                        await self._start_publisher(restore_state)
             result_response = await self._session.post(
                 f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/supervisor-output",
                 json={"kind": "speaker_test", "service": None, "payload": result,
@@ -1066,7 +1071,8 @@ class PreviewAgent:
         # The cue and TTS share one physical ALSA output. Finish and release
         # the cue before LiveKit can deliver the greeting; background playback
         # races aplay and makes greeting delivery intermittently fail busy.
-        await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
+        async with self._speaker_operation_lock:
+            await asyncio.to_thread(_play_audio_effect, self.audio_playback_device, "motion")
         try:
             r = await self._session.post(
                 f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/request-session",
@@ -1317,6 +1323,11 @@ class LiveKitPublisher:
                         process.wait(timeout=2)
                     except subprocess.TimeoutExpired:
                         process.terminate()
+                        try:
+                            process.wait(timeout=1)
+                        except subprocess.TimeoutExpired:
+                            process.kill()
+                            process.wait(timeout=1)
 
                 def close(self) -> None:
                     return
@@ -1493,16 +1504,24 @@ class LiveKitPublisher:
                 else:
                     data = b"".join(raw[i:i + 2] * OUT_CHANNELS for i in range(0, len(raw), 2))
                 write_queue.put(data)
-        except Exception as e:
-            logger.warning(f"audio out stream error: {e}")
-        finally:
-            write_queue.put(None)
-            writer_thread.join(timeout=2.0)
+        except Exception as e:
+            logger.warning(f"audio out stream error: {e}")
+        finally:
+            cancelling = bool(asyncio.current_task() and asyncio.current_task().cancelling())
+            if cancelling:
+                # On publisher teardown, close ALSA first. Waiting for the
+                # writer while aplay still owns the device leaves hw:X,Y busy
+                # long enough for the queued dashboard test to fail.
+                stream_failed.set()
+                out.stop_stream()
+            write_queue.put(None)
+            writer_thread.join(timeout=2.0)
             logger.info(
                 f"audio out: {sid} received {frame_count} frames, "
                 f"writer wrote {written_frames[0]} chunks, queue backlog at close={write_queue.qsize()}"
             )
-            out.stop_stream()
+            if not cancelling:
+                out.stop_stream()
             out.close()
             if pa is not None:
                 pa.terminate()