infinicode 2.8.95 → 2.8.96

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -160,3 +160,15 @@ Required result: `playback_started  ok`.
   whether motion creates a conversation, not whether the camera worker runs.
 - `auto`, `default`, and `first` resolve to `/dev/robopark-camera` when present,
   otherwise `/dev/video0`; those literal strings are never passed to OpenCV.
+
+## Audio Ownership Contract (2.8.96+)
+
+- Fleet microphone selection is resolved by stable USB product label on every
+  inventory refresh. The current stack maps microphone to `hw:3,0` and speaker
+  to `hw:2,0`.
+- A LiveKit microphone track is healthy only after the robot captures and
+  publishes real PCM. Publishing an empty track is not readiness.
+- Linux capture probes `plughw` at 48 kHz, falls back to 44.1 kHz with
+  resampling, and releases the microphone lock after every failed attempt.
+- Pipeline failures include the selected device and exact ALSA startup error.
+  A flat browser meter means missing PCM, not a quiet room.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.95",
+  "version": "2.8.96",
   "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

@@ -1238,6 +1238,7 @@ class LiveKitPublisher:
         self._capture: Optional["VideoCapture"] = None
         self._mic_capture: Optional["AudioCapture"] = None
         self._mic_streaming = asyncio.Event()
+        self._mic_error: Optional[str] = None
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
         # the camera is being handed between preview and voice sessions.
@@ -1335,10 +1336,16 @@ class LiveKitPublisher:
             try:
                 await asyncio.wait_for(self._mic_streaming.wait(), timeout=5.0)
             except asyncio.TimeoutError:
+                detail = self._mic_error or f"no PCM received from {self.agent.audio_capture_device}"
                 await self.agent._report_pipeline(
-                    "microphone_published", "blocked", "Microphone track published but PCM capture did not start"
+                    "microphone_published", "blocked",
+                    f"Microphone track published but PCM capture did not start: {detail}",
+                    {"device": self.agent.audio_capture_device, "error": detail},
+                )
+                logger.warning(
+                    "microphone PCM is not ready (%s); keeping the session alive while capture retries",
+                    detail,
                 )
-                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()))
@@ -1688,6 +1695,7 @@ class LiveKitPublisher:
             except asyncio.CancelledError:
                 raise
             except Exception as e:
+                self._mic_error = str(e)
                 logger.warning(
                     f"audio_loop: capture failed on {self.agent.audio_capture_device}: {e}; retrying"
                 )
@@ -1709,7 +1717,8 @@ class LiveKitPublisher:
             logger.warning("audio_loop: create_audio_capture returned None, mic will not publish")
             return
         self._mic_capture = mic
-        logger.info(f"audio_loop: mic capture started ({type(mic).__name__})")
+        self._mic_error = None
+        logger.info(f"audio_loop: mic capture started ({type(mic).__name__})")
         # Read in bigger batches (100ms) instead of one 20ms frame per
         # asyncio.to_thread() dispatch. Each dispatch/poll cycle has a fixed
         # overhead (~30ms observed on this machine) that dominates when the
@@ -1949,46 +1958,92 @@ class AlsaAudioCapture(AudioCapture):
     """Capture Linux PCM through the same ALSA path used by onsite tests."""
 
     def __init__(self, device: str):
+        import os
         import re
+        import select
         import subprocess
         from media_lock import media_lock
 
         match = re.search(r"\b(hw:\d+,\d+)\b", device)
         if not match:
             raise ValueError(f"no ALSA hardware address in {device!r}")
-        alsa_device = f"plug{match.group(1)}"
         self.buffer = bytearray()
-        self.media_guard = media_lock("microphone", timeout=5.0).acquire()
-        try:
-            self.process = subprocess.Popen(
-                [
-                    "arecord", "-q", "-D", alsa_device, "-t", "raw",
-                    "-f", "S16_LE", "-r", "48000", "-c", "1",
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-            )
-        except Exception:
-            self.media_guard.release()
-            raise
-        if self.process.stdout is None:
-            self.process.kill()
-            self.process.wait(timeout=1)
+        self.media_guard = media_lock("microphone", timeout=1.5).acquire()
+        self.process = None
+        self.source_rate = 48000
+        self.rate_state = None
+        errors = []
+        # The fleet USB microphone normally accepts 48 kHz through ALSA's
+        # plug layer. Some firmware revisions expose only native 44.1 kHz;
+        # accept that rate and resample below rather than publishing silence.
+        for source_rate in (48000, 44100):
+            alsa_device = f"plug{match.group(1)}"
+            process = None
+            try:
+                process = subprocess.Popen(
+                    [
+                        "arecord", "-q", "-D", alsa_device, "-t", "raw",
+                        "-f", "S16_LE", "-r", str(source_rate), "-c", "1",
+                        "--period-size", str(max(256, source_rate // 50)),
+                    ],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    bufsize=0,
+                )
+                if process.stdout is None:
+                    raise RuntimeError("arecord did not provide a PCM stream")
+                ready, _, _ = select.select([process.stdout], [], [], 2.0)
+                if not ready:
+                    if process.poll() is None:
+                        raise TimeoutError("arecord produced no PCM within 2 seconds")
+                    detail = process.stderr.read().decode("utf-8", errors="replace").strip() if process.stderr else ""
+                    raise OSError(detail or f"arecord exited {process.returncode}")
+                first = os.read(process.stdout.fileno(), max(2048, source_rate // 25 * 2))
+                if not first:
+                    detail = process.stderr.read().decode("utf-8", errors="replace").strip() if process.stderr else ""
+                    raise OSError(detail or "arecord returned an empty PCM frame")
+                self.process = process
+                self.source_rate = source_rate
+                self.alsa_device = alsa_device
+                if source_rate != 48000:
+                    import audioop
+                    first, self.rate_state = audioop.ratecv(
+                        first, 2, 1, source_rate, 48000, self.rate_state
+                    )
+                self.buffer.extend(first)
+                break
+            except Exception as exc:
+                errors.append(f"{source_rate}Hz: {exc}")
+                if process is not None:
+                    if process.poll() is None:
+                        process.terminate()
+                    try:
+                        process.wait(timeout=1)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                        process.wait(timeout=1)
+        if self.process is None:
             self.media_guard.release()
-            raise RuntimeError("arecord did not provide a PCM stream")
-        self.alsa_device = alsa_device
+            raise OSError(f"ALSA capture failed on plug{match.group(1)} ({'; '.join(errors)})")
 
     def read(self, samples_per_frame: int):
+        import audioop
+        import os
         from livekit import rtc
 
         bytes_needed = samples_per_frame * 2
+        source_bytes_needed = max(2, int(samples_per_frame * self.source_rate / 48000) * 2)
         while len(self.buffer) < bytes_needed:
-            chunk = self.process.stdout.read(bytes_needed - len(self.buffer))
+            chunk = os.read(self.process.stdout.fileno(), source_bytes_needed)
             if not chunk:
                 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'}")
+            if self.source_rate != 48000:
+                chunk, self.rate_state = audioop.ratecv(
+                    chunk, 2, 1, self.source_rate, 48000, self.rate_state
+                )
             self.buffer.extend(chunk)
         data = bytes(self.buffer[:bytes_needed])
         del self.buffer[:bytes_needed]