infinicode 2.8.99 → 2.8.100

package/dist/robopark/robot-runtime.js

@@ -139,6 +139,12 @@ export async function roboparkRobotRuntime(opts) {
             // from these USB product labels on every inventory refresh.
             ROBOPARK_AUDIO_INPUT_MATCH: 'Usb Audio Device: USB Audio',
             ROBOPARK_AUDIO_OUTPUT_MATCH: 'USB Audio Device: -',
+            // Launch hardware has no acoustic echo cancellation. Suppress mic PCM
+            // only while audible robot speech is playing, then hold briefly for
+            // room echo decay so VAD cannot interrupt the robot with its own voice.
+            ROBOPARK_HALF_DUPLEX: 'true',
+            ROBOPARK_ECHO_TAIL_MS: '700',
+            ROBOPARK_ECHO_GATE_PEAK: '96',
             // Inventory changes should reach the Control Center promptly.
             HEARTBEAT_INTERVAL: '5',
         },

package/docs/ROBOPARK_PRODUCTION_MEMORY.md

@@ -199,3 +199,16 @@ Required result: `playback_started  ok`.
   rejects duplicate assignments, limits pulses to 10 seconds, serializes all
   actuation, and de-energizes every registered relay on errors and shutdown.
 - A missing or busy GPIO driver is a failed test, never a simulated success.
+
+## Robot Speaker Echo Contract (2.8.100+)
+
+- The launch USB speaker/microphone stack has no hardware acoustic echo
+  cancellation, so production uses robot-side half-duplex echo suppression.
+- While outbound TTS contains audible PCM, the Pi publishes timing-correct
+  silence instead of amplified microphone PCM. The microphone track remains
+  connected and resumes after a 700 ms acoustic decay tail.
+- Silent frames on the persistent TTS track do not hold the gate open. Output
+  peak detection releases the visitor microphone between responses.
+- `ROBOPARK_HALF_DUPLEX`, `ROBOPARK_ECHO_TAIL_MS`, and
+  `ROBOPARK_ECHO_GATE_PEAK` are explicit runtime controls. Disable half-duplex
+  only after deploying real acoustic echo cancellation.

package/package.json

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

@@ -1284,6 +1284,19 @@ class LiveKitPublisher:
         self._mic_capture: Optional["AudioCapture"] = None
         self._mic_streaming = asyncio.Event()
         self._mic_error: Optional[str] = None
+        # The launch hardware has no acoustic echo cancellation. Publishing
+        # the amplified USB microphone while the robot speaker plays TTS makes
+        # the voice worker hear itself and trigger barge-in, truncating or
+        # chopping its own response. Keep the track alive with silence while
+        # playback is active, plus a short room-echo decay tail.
+        self._half_duplex = str(os.getenv("ROBOPARK_HALF_DUPLEX", "true")).lower() in (
+            "1", "true", "yes", "on",
+        )
+        self._speaker_playback_active = threading.Event()
+        self._speaker_gate_until = 0.0
+        self._speaker_echo_tail = max(
+            0.1, min(float(os.getenv("ROBOPARK_ECHO_TAIL_MS", "700")) / 1000.0, 2.0)
+        )
         # 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.
@@ -1524,12 +1537,41 @@ class LiveKitPublisher:
         stream_failed = threading.Event()
         playback_reported = threading.Event()
         event_loop = asyncio.get_running_loop()
+        echo_gate_peak = max(16, min(int(os.getenv("ROBOPARK_ECHO_GATE_PEAK", "96")), 4096))
+
+        def _outbound_peak(chunk: bytes) -> int:
+            if len(chunk) < 2:
+                return 0
+            try:
+                samples = memoryview(chunk).cast("h")
+                # Stereo duplication means sampling every eighth value is
+                # sufficient and keeps the writer thread lightweight.
+                return max((abs(int(value)) for value in samples[::8]), default=0)
+            except (TypeError, ValueError):
+                return 0
+
+        def _open_echo_gate() -> None:
+            if not self._half_duplex:
+                return
+            self._speaker_playback_active.set()
+            self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
+
+        def _extend_echo_gate() -> None:
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
 
-        def _safe_write(chunk: bytes) -> bool:
-            if stream_failed.is_set():
-                return False
+        def _safe_write(chunk: bytes) -> bool:
+            if stream_failed.is_set():
+                return False
             try:
+                audible = _outbound_peak(chunk) >= echo_gate_peak
+                if audible:
+                    _open_echo_gate()
+                elif time.monotonic() >= self._speaker_gate_until:
+                    self._speaker_playback_active.clear()
                 out.write(chunk)
+                if audible:
+                    _extend_echo_gate()
                 if not playback_reported.is_set():
                     playback_reported.set()
                     asyncio.run_coroutine_threadsafe(
@@ -1661,6 +1703,9 @@ class LiveKitPublisher:
                 pa.terminate()
             if speaker_guard is not None:
                 speaker_guard.release()
+            if self._half_duplex:
+                self._speaker_gate_until = time.monotonic() + self._speaker_echo_tail
+                self._speaker_playback_active.clear()
 
     async def stop(self) -> None:
         self._stop_event.set()
@@ -1783,8 +1828,9 @@ class LiveKitPublisher:
         _diag_count = 0
         _diag_last_log = time.monotonic()
         _diag_read_ms = 0.0
-        _diag_publish_ms = 0.0
-        batch_interval = BATCH_MS / 1000
+        _diag_publish_ms = 0.0
+        _echo_gate_was_active = False
+        batch_interval = BATCH_MS / 1000
         while not self._stop_event.is_set():
             _iter_start = time.monotonic()
             _t0 = time.monotonic()
@@ -1792,10 +1838,27 @@ class LiveKitPublisher:
             _t1 = time.monotonic()
             if batch is not None:
                 data = bytes(batch.data)
-                _pub_start = time.monotonic()
-                for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
+                _pub_start = time.monotonic()
+                for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
                     chunk = data[off:off + bytes_per_frame]
-                    chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    echo_gate_active = self._half_duplex and (
+                        self._speaker_playback_active.is_set()
+                        or time.monotonic() < self._speaker_gate_until
+                    )
+                    if echo_gate_active:
+                        # Preserve 20 ms frame cadence; only suppress content.
+                        # Stopping publication would create gaps and destabilize
+                        # VAD/endpointing when listening resumes.
+                        chunk = b"\x00" * len(chunk)
+                        p = 0
+                    else:
+                        chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
+                    if echo_gate_active != _echo_gate_was_active:
+                        logger.info(
+                            "audio_loop: speaker echo gate %s",
+                            "active" if echo_gate_active else "released",
+                        )
+                        _echo_gate_was_active = echo_gate_active
                     frame = self.rtc.AudioFrame(
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )