infinicode 2.8.90 → 2.8.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.90",
+  "version": "2.8.92",
   "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",
@@ -1251,17 +1257,14 @@ class LiveKitPublisher:
         # — until it finished, so a short "Hello friend!" greeting could be
         # over and gone before we ever got a chance to subscribe to it.
         if audio_enabled:
-            self._tasks.append(asyncio.create_task(self._audio_loop()))
+            self._tasks.append(asyncio.create_task(self._audio_retry_loop()))
             try:
                 await asyncio.wait_for(self._mic_streaming.wait(), timeout=5.0)
-                await self.agent._report_pipeline(
-                    "microphone_published", "ok", "Microphone track published with live PCM frames"
-                )
             except asyncio.TimeoutError:
                 await self.agent._report_pipeline(
                     "microphone_published", "blocked", "Microphone track published but PCM capture did not start"
                 )
-                raise RuntimeError(f"microphone capture did not start for {self.agent.audio_capture_device}")
+                logger.warning("microphone PCM is not ready; keeping the session alive while capture retries")
 
         if self._capture and self.video_source:
             self._tasks.append(asyncio.create_task(self._video_loop()))
@@ -1317,6 +1320,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 +1501,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()
@@ -1577,7 +1593,29 @@ class LiveKitPublisher:
         except Exception as e:
             logger.debug(f"preview motion sampling failed: {e}")
 
-    async def _audio_loop(self) -> None:
+    async def _audio_retry_loop(self) -> None:
+        """Keep microphone capture alive across transient ALSA ownership errors."""
+        while not self._stop_event.is_set():
+            try:
+                await self._audio_loop()
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                logger.warning(
+                    f"audio_loop: capture failed on {self.agent.audio_capture_device}: {e}; retrying"
+                )
+            finally:
+                mic = self._mic_capture
+                self._mic_capture = None
+                if mic is not None:
+                    await asyncio.to_thread(mic.stop)
+            if not self._stop_event.is_set():
+                try:
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    pass
+
+    async def _audio_loop(self) -> None:
         assert self.audio_source is not None
         mic = create_audio_capture(self.agent.audio_capture_device)
         if mic is None:
@@ -1623,7 +1661,12 @@ class LiveKitPublisher:
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )
                     await self.audio_source.capture_frame(frame)
-                    self._mic_streaming.set()
+                    if not self._mic_streaming.is_set():
+                        self._mic_streaming.set()
+                        await self.agent._report_pipeline(
+                            "microphone_published", "ok",
+                            "Microphone track published with live PCM frames",
+                        )
                     p = audioop.max(chunk, 2)
                     _diag_peak = max(_diag_peak, p)
                     _diag_count += 1
@@ -1833,7 +1876,7 @@ class AlsaAudioCapture(AudioCapture):
                 "-f", "S16_LE", "-r", "48000", "-c", "1",
             ],
             stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
         )
         if self.process.stdout is None:
             raise RuntimeError("arecord did not provide a PCM stream")
@@ -1846,7 +1889,10 @@ class AlsaAudioCapture(AudioCapture):
         while len(self.buffer) < bytes_needed:
             chunk = self.process.stdout.read(bytes_needed - len(self.buffer))
             if not chunk:
-                raise OSError(f"ALSA capture stopped on {self.alsa_device}")
+                detail = ""
+                if self.process.stderr is not None:
+                    detail = self.process.stderr.read().decode("utf-8", errors="replace").strip()
+                raise OSError(f"ALSA capture stopped on {self.alsa_device}: {detail or 'no PCM data'}")
             self.buffer.extend(chunk)
         data = bytes(self.buffer[:bytes_needed])
         del self.buffer[:bytes_needed]
@@ -1864,6 +1910,7 @@ class AlsaAudioCapture(AudioCapture):
                 self.process.wait(timeout=2)
             except Exception:
                 self.process.kill()
+                self.process.wait(timeout=1)
 
 
 class PyAudioCapture(AudioCapture):