infinicode 2.8.79 → 2.8.81

package/dist/kernel/federation/dashboard-html.js

@@ -6819,6 +6819,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
         if(!result.queued) throw new Error(result.reason||'trigger was not queued');
         showOut('full production test queued for '+(n.label||n.name));
         pollPipeline(n);
+        // The stream endpoint is initially idle and becomes active only after
+        // the robot consumes the trigger. Retry through that transition.
+        [400,1200,2500,4500].forEach(function(delay){setTimeout(function(){if(drawerId)startMicMonitor(n);},delay);});
       }).catch(function(e){ showOut('production test: '+e.message); pollPipeline(n); }).finally(function(){ if(start){ start.disabled=false; start.textContent='Start full test'; } });
     }
     function startPipelineTest(n){
@@ -6969,19 +6972,25 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var note=$('pk-camnote'), res=$('pk-camres');
       try{
         var LK=window.LivekitClient; lkRoom=new LK.Room();
-        lkRoom.on(LK.RoomEvent.TrackSubscribed, function(track){
+        lkRoom.on(LK.RoomEvent.TrackSubscribed, function(track,publication,participant){
           if(track.kind==='video'){
             if(audioOnly)return;
             var el=track.attach(); el.setAttribute('playsinline',''); el.muted=true; el.autoplay=true;
             var cv=$('pk-camcv'); if(cv&&cv.parentNode) cv.parentNode.replaceChild(el, cv);
             if(res) res.textContent='LIVE'; if(note) note.textContent='live camera via LiveKit · '+esc(info.room);
           } else if(track.kind==='audio'){
-            // Listen only to the robot's published microphone. Agent TTS may
-            // also be present in the room, but hearing that directly would
-            // bypass the physical speaker -> microphone round-trip test.
-            if(track.name&&track.name!=='microphone')return;
+            // Track names are backend-dependent ("mic", device labels, or
+            // empty). Identify the robot by participant instead; reject the
+            // voice worker/viewer so this remains the physical robot mic.
+            var identity=String(participant&&participant.identity||'');
+            var expected=String(schedId(n)||'').toLowerCase();
+            var nodeName=String(n.name||'').toLowerCase();
+            var lowerIdentity=identity.toLowerCase();
+            var isWorker=/(agent|operator|viewer)/.test(lowerIdentity);
+            var isRobot=!isWorker&&(lowerIdentity===expected||lowerIdentity===nodeName||lowerIdentity.indexOf(expected)>-1||lowerIdentity.indexOf(nodeName)>-1);
+            if(!isRobot){if(window.console)console.debug('RoboPark ignored non-robot audio track',identity,track.name,publication&&publication.source);return;}
             hookMicAnalyser(track);
-            micMonitorState='live track published';
+            micMonitorState='live robot mic from '+identity;
             var micState=$('pk-micstate');if(micState)micState.textContent='selected '+selectedRobotMic()+' · live track published';
             // Muted by default: this is the camera-preview panel, running on
             // the SAME physical device as the robot in local testing. Auto-
@@ -6991,9 +7000,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
             // that drowns out the actual conversation. The VU meter above
             // (hookMicAnalyser) taps the raw track directly and works fine
             // muted.
-            var audio=track.attach(); audio.autoplay=true; audio.controls=false; audio.muted=!micMonitorAudible; audio.volume=micMonitorVolume;audio.style.display='none'; document.body.appendChild(audio); lkAudioEls.push(audio);
+            var audio=track.attach(); audio.autoplay=true; audio.playsInline=true;audio.setAttribute('playsinline','');audio.controls=false; audio.muted=!micMonitorAudible; audio.volume=micMonitorVolume;audio.style.display='none'; document.body.appendChild(audio); lkAudioEls.push(audio);
             var listenNote=$('pk-mic-listen-note');if(listenNote&&micMonitorAudible)listenNote.textContent='Robot mic is playing in this browser. Use headphones.';
-            audio.play().catch(function(){});
+            audio.play().catch(function(e){var listenNote=$('pk-mic-listen-note');if(listenNote)listenNote.textContent='Browser blocked robot audio: '+e.message+'. Click Listen in browser.';});
           }
         });
         lkRoom.on(LK.RoomEvent.Disconnected, function(){lkRoom=null;micAnalyser=null;micMonitorConnecting=false;micMonitorState='session ended';var micState=$('pk-micstate');if(micState)micState.textContent='selected '+selectedRobotMic()+' · session ended';if(!audioOnly&&note)note.textContent='session ended';if(!audioOnly&&res)res.textContent='—';});
@@ -7155,16 +7164,14 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var banner = result.pass
         ? '<div class="pk-spk-banner ok">✓ '+(isTts?'cached voice playback OK':'speaker round-trip OK')+'</div>'
         : '<div class="pk-spk-banner bad">✗ no signal detected</div>';
-      var meta = '<div class="pk-spk-meta">'
-        + '<div><span class="l">peak</span><span class="v">'+esc(result.recorded_peak_db+' dB')+'</span></div>'
-        + '<div><span class="l">RMS</span><span class="v">'+esc(result.recorded_rms_db+' dB')+'</span></div>'
-        + '<div><span class="l">threshold</span><span class="v">'+esc(result.threshold_db+' dB')+'</span></div>'
+      var meta = '<div class="pk-spk-meta">'
+        + (result.playback_only?'':'<div><span class="l">peak</span><span class="v">'+esc(result.recorded_peak_db+' dB')+'</span></div><div><span class="l">RMS</span><span class="v">'+esc(result.recorded_rms_db+' dB')+'</span></div><div><span class="l">threshold</span><span class="v">'+esc(result.threshold_db+' dB')+'</span></div>')
         + (isTts?'<div><span class="l">voice</span><span class="v">'+esc((result.tts_provider||'tts')+' / '+(result.tts_voice||'default'))+'</span></div><div><span class="l">cache</span><span class="v">'+(result.cache_hit?'hit':'generated')+'</span></div>':'<div><span class="l">frequency</span><span class="v">'+esc(Math.round(result.frequency)+' Hz')+'</span></div>')
         + '<div><span class="l">duration</span><span class="v">'+esc(result.duration+' s')+'</span></div>'
         + '<div><span class="l">latency</span><span class="v">'+esc(result.duration_ms+' ms')+'</span></div>'
         + '<div><span class="l">output</span><span class="v">'+esc(result.output_device)+'</span></div>'
         + '<div><span class="l">input</span><span class="v">'+esc(result.input_device)+'</span></div>'
-        + '<div><span class="l">format</span><span class="v">'+esc((result.output_sample_rate||result.sample_rate)+' Hz / '+(result.output_channels||1)+'ch out · '+(result.input_sample_rate||result.sample_rate)+' Hz / '+(result.input_channels||1)+'ch in')+'</span></div>'
+        + '<div><span class="l">format</span><span class="v">'+esc((result.output_sample_rate||result.sample_rate)+' Hz / '+(result.output_channels||1)+'ch out'+(result.playback_only?'':' · '+(result.input_sample_rate||result.sample_rate)+' Hz / '+(result.input_channels||1)+'ch in'))+'</span></div>'
         + '</div>';
       var diag = result.diagnostic ? '<div class="pk-spk-diag">'+esc(result.diagnostic)+'</div>' : '';
       host.innerHTML = '<div class="pk-spk-result '+(result.pass?'ok':'bad')+'">'
@@ -7187,7 +7194,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
       // the real recording.
       _spkTestSetLive(robotId, {live:true, rms: 0.45, pass: undefined, waveform: null});
       rpAction('POST','/robopark/api/robots/'+encodeURIComponent(robotId)+'/shell/speaker-test',
-        {mode:mode, text:phrase, frequency:freq, duration:dur, amplitude:0.6, threshold_db:-30, output:output, input:input, output_name:outputName, input_name:inputName})
+        {mode:mode, playback_only:mode==='tts', text:phrase, frequency:freq, duration:dur, amplitude:0.6, threshold_db:-30, output:output, input:input, output_name:outputName, input_name:inputName})
         .then(function(q){
           // long-poll up to 8s, then fall back to 12s of result polling
           if(status) status.textContent = mode==='tts'?'playing cached voice on '+selectedRobotOutput()+'…':'playing tone + recording…';
@@ -7233,7 +7240,8 @@ button.act:disabled{opacity:0.5;cursor:default;}
         var status = $('pk-spk-test-stateline');
         if(status){
           if(!result || !result.ok){ status.textContent = '✗ test failed'; }
-          else if(result.pass){ status.textContent = '✓ pass · '+result.recorded_peak_db+' dB peak'; }
+          else if(result.playback_only&&result.played){ status.textContent = '✓ speaker playback completed'; }
+          else if(result.pass){ status.textContent = '✓ pass · '+result.recorded_peak_db+' dB peak'; }
           else { status.textContent = '✗ no signal — '+result.recorded_peak_db+' dB peak'; }
         }
         var btn = $('pk-spk-runtest'); if(btn){ btn.disabled = false; btn.textContent = (($('pk-spk-mode')||{}).value==='tone'?'Run tone test':'Play cached voice'); }

package/package.json

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

@@ -3477,6 +3477,7 @@ class SpeakerTestRequest(BaseModel):
     output_name: Optional[str] = None
     input_name: Optional[str] = None
     sample_rate: Optional[int] = None
+    playback_only: Optional[bool] = None
 
 
 async def _cached_speaker_tts(robot_id: str, text: str) -> dict:
@@ -3533,7 +3534,8 @@ async def robot_speaker_test(robot_id: str, payload: SpeakerTestRequest):
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
         async with db.execute(
-            "SELECT id FROM devices WHERE id = ? OR lower(name) = lower(?) "
+            "SELECT id, audio_device, audio_output_device, device_inventory FROM devices "
+            "WHERE id = ? OR lower(name) = lower(?) "
             "ORDER BY CASE WHEN id = ? THEN 0 ELSE 1 END LIMIT 1",
             (robot_id, robot_id, robot_id),
         ) as cursor:
@@ -3542,7 +3544,30 @@ async def robot_speaker_test(robot_id: str, payload: SpeakerTestRequest):
         raise HTTPException(404, f"Robot device not found: {robot_id}")
     device_id = device["id"]
     params = payload.model_dump(exclude_none=True)
+    # Scheduler persistence is authoritative. Dashboard state can be stale
+    # while heartbeat polling rebuilds the drawer, so never let it silently
+    # route a test to a different device than the one the operator saved.
+    if device["audio_device"] not in (None, ""):
+        params["input"] = str(device["audio_device"])
+    if device["audio_output_device"] not in (None, ""):
+        params["output"] = str(device["audio_output_device"])
+    try:
+        inventory = json.loads(device["device_inventory"] or "{}")
+    except (TypeError, ValueError):
+        inventory = {}
+    for field, inventory_key, name_key in (
+        ("input", "audio_input", "input_name"),
+        ("output", "audio_output", "output_name"),
+    ):
+        selected = str(params.get(field, ""))
+        for item in inventory.get(inventory_key, []) or []:
+            if str(item.get("id", "")) == selected:
+                params[name_key] = str(item.get("name") or selected)
+                break
     if payload.mode == "tts":
+        # Cached voice is a speaker test. Do not also seize the microphone,
+        # which may be owned by the live preview/conversation publisher.
+        params.setdefault("playback_only", True)
         params.update(await _cached_speaker_tts(robot_id, payload.text or ""))
     elif payload.mode != "tone":
         raise HTTPException(422, "mode must be tone or tts")

package/packages/robopark/scheduler/preview_agent.py

@@ -392,6 +392,10 @@ class PreviewAgent:
         self.enrollment_token: Optional[str] = cfg.get("enrollment_token")
         self.video_device = cfg.get("video_device", os.getenv("VIDEO_DEVICE", "auto"))
         self.audio_device = cfg.get("audio_device", os.getenv("AUDIO_DEVICE", "default"))
+        # Scheduler inventory IDs come from RoboVision/sounddevice. They are
+        # not guaranteed to equal PyAudio's device indexes, so capture must
+        # 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"))
         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))
@@ -672,6 +676,16 @@ class PreviewAgent:
             if data.get("audio_device") is not None:
                 changed = changed or self.audio_device != data["audio_device"]
                 self.audio_device = data["audio_device"]
+                inventory = data.get("device_inventory") or {}
+                selected = str(self.audio_device)
+                self.audio_capture_device = next(
+                    (
+                        str(item.get("name"))
+                        for item in inventory.get("audio_input", [])
+                        if str(item.get("id")) == selected and item.get("name")
+                    ),
+                    self.audio_device,
+                )
             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"]
@@ -1457,7 +1471,7 @@ class LiveKitPublisher:
 
     async def _audio_loop(self) -> None:
         assert self.audio_source is not None
-        mic = create_audio_capture(self.agent.audio_device)
+        mic = create_audio_capture(self.agent.audio_capture_device)
         if mic is None:
             logger.warning("audio_loop: create_audio_capture returned None, mic will not publish")
             return

package/packages/robopark/scheduler/robot_supervisor.py

@@ -588,6 +588,7 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     except ImportError as e:
         return {"ok": False, "error": f"pyaudio not installed on this robot: {e}"}
     mode = str(params.get("mode", "tone")).lower()
+    playback_only = bool(params.get("playback_only", mode == "tts"))
     freq = float(params.get("frequency", SPEAKER_TEST_FREQUENCY_HZ))
     dur = float(params.get("duration", SPEAKER_TEST_DURATION_S))
     amp = float(params.get("amplitude", SPEAKER_TEST_AMPLITUDE))
@@ -622,13 +623,13 @@ def _speaker_roundtrip_test(params: dict) -> dict:
 
     pa = pyaudio.PyAudio()
     out_idx = _resolve_audio_device(pa, out_name, "output")
-    in_idx = _resolve_audio_device(pa, in_name, "input")
+    in_idx = None if playback_only else _resolve_audio_device(pa, in_name, "input")
     def _dev_name(idx):
         if idx is None: return "(default)"
         try: return pa.get_device_info_by_index(idx).get("name", str(idx))
         except Exception: return str(idx)
     out_label = _dev_name(out_idx)
-    in_label = _dev_name(in_idx)
+    in_label = "not opened (speaker-only test)" if playback_only else _dev_name(in_idx)
 
     recorded_peak = 0
     recorded_rms = 0.0
@@ -644,11 +645,12 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         out_stream, output_rate, output_channels, out_info = _open_pcm_stream(
             pa, pyaudio, "output", out_idx, source_rate
         )
-        in_stream, input_rate, input_channels, in_info = _open_pcm_stream(
-            pa, pyaudio, "input", in_idx, source_rate
-        )
         out_label = str(out_info.get("name", out_label))
-        in_label = str(in_info.get("name", in_label))
+        if not playback_only:
+            in_stream, input_rate, input_channels, in_info = _open_pcm_stream(
+                pa, pyaudio, "input", in_idx, source_rate
+            )
+            in_label = str(in_info.get("name", in_label))
 
         if mono_pcm is not None:
             output_mono = _resample_pcm16_mono(mono_pcm, source_rate, output_rate)
@@ -671,7 +673,8 @@ def _speaker_roundtrip_test(params: dict) -> dict:
             raw = output_mono
 
         chunk = 1024
-        in_stream.start_stream()
+        if in_stream is not None:
+            in_stream.start_stream()
         chunk_bytes = chunk * 2 * output_channels
         pos = 0
         peak_acc = 0
@@ -682,8 +685,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
             end = min(pos + chunk_bytes, len(raw))
             out_stream.write(raw[pos:end])
             pos = end
-            try:
-                avail = in_stream.get_read_available()
+            try:
+                if in_stream is None:
+                    continue
+                avail = in_stream.get_read_available()
                 if avail and avail > 0:
                     data = in_stream.read(avail, exception_on_overflow=False)
                     for s in range(0, len(data) - 1, 2):
@@ -695,18 +700,20 @@ def _speaker_roundtrip_test(params: dict) -> dict:
             except Exception:
                 pass
         out_stream.stop_stream(); out_stream.close(); out_stream = None
-        try:
-            tail_frames = min(int(input_rate * 0.35), max(0, in_stream.get_read_available()))
-            tail = in_stream.read(tail_frames, exception_on_overflow=False) if tail_frames else b""
-            for s in range(0, len(tail) - 1, 2):
-                v = int.from_bytes(tail[s:s+2], "little", signed=True)
-                a = abs(v)
-                if a > peak_acc: peak_acc = a
-                rms_acc += v * v
-                n_samp += 1
-        except Exception:
-            pass
-        in_stream.stop_stream(); in_stream.close(); in_stream = None
+        if in_stream is not None:
+            try:
+                tail_frames = min(int(input_rate * 0.35), max(0, in_stream.get_read_available()))
+                tail = in_stream.read(tail_frames, exception_on_overflow=False) if tail_frames else b""
+                for s in range(0, len(tail) - 1, 2):
+                    v = int.from_bytes(tail[s:s+2], "little", signed=True)
+                    a = abs(v)
+                    if a > peak_acc: peak_acc = a
+                    rms_acc += v * v
+                    n_samp += 1
+            except Exception:
+                pass
+        if in_stream is not None:
+            in_stream.stop_stream(); in_stream.close(); in_stream = None
         recorded_peak = peak_acc
         recorded_rms = (rms_acc / max(1, n_samp)) ** 0.5
     except Exception as e:
@@ -721,10 +728,30 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         try: pa.terminate()
         except Exception: pass
     duration_ms = int((time.monotonic() - t0) * 1000)
-    if err:
+    if err:
         return {"ok": False, "error": err, "duration_ms": duration_ms,
                 "output_device": out_label, "input_device": in_label,
-                "frequency": freq, "duration": dur}
+                "frequency": freq, "duration": dur}
+    if playback_only:
+        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": output_rate,
+            "output_channels": output_channels,
+            "output_device": out_label,
+            "input_device": in_label,
+            "diagnostic": "speaker playback completed; microphone was intentionally not opened",
+        }
     if recorded_peak > 0:
         peak_db = 20.0 * math.log10(recorded_peak / 32767.0)
     else: