fix(meet-audio): caption pipeline + echo prevention + mascot rendering

app/src-tauri/src/lib.rs

@@ -3174,6 +3174,10 @@ pub fn run() {
                             request_id: request_id.clone(),
                             meet_url: meet_url.clone(),
                             display_name: "OpenHuman Dev".to_string(),
+                            // Dev-auto launch has no real user identity — the
+                            // wake gate will fail-closed (no wakes fire) which
+                            // is the safe posture for an automated harness.
+                            owner_display_name: String::new(),
                         };
                         match meet_call::meet_call_open_window(app_handle.clone(), state, args)
                             .await

app/src-tauri/src/meet_audio/audio_bridge.js

@@ -45,9 +45,13 @@
 
   function ensureContext() {
     if (ctx) {
-      console.log(
-        "[openhuman-audio-bridge] reuse AudioContext state=" + ctx.state
-      );
+      // Resume if suspended (CEF suspends until user gesture; the
+      // meet_scanner's synthetic clicks count as gestures on some
+      // builds but not all).
+      if (ctx.state === "suspended") {
+        ctx.resume().catch(function () {});
+        console.log("[openhuman-audio-bridge] resumed suspended AudioContext");
+      }
       return ctx;
     }
     var requestedRate = SAMPLE_RATE;
@@ -97,6 +101,29 @@
     return out;
   }
 
+  // Track every scheduled AudioBufferSource so __openhumanFlushAudio
+  // can stop them on barge-in (user re-asks during a long bot reply).
+  // Without this list, only the queue tail past `nextStartTime` would
+  // be cancellable; anything already start()-ed plays to completion.
+  var activeSources = [];
+
+  // Stop in-flight playback and reset the schedule cursor. Called by
+  // the Rust shell when the brain cancels outbound (new wake fires
+  // mid-reply). Returns the number of sources that were stopped, so
+  // the shell can log how much speech got cut.
+  window.__openhumanFlushAudio = function () {
+    var stopped = 0;
+    while (activeSources.length) {
+      var s = activeSources.pop();
+      try { s.stop(); stopped++; } catch (_) {}
+      try { s.disconnect(); } catch (_) {}
+    }
+    if (ctx) {
+      nextStartTime = ctx.currentTime;
+    }
+    return stopped;
+  };
+
   // Public push API. Returns the duration in seconds the chunk added
   // to the queue, mostly for diagnostics; the shell ignores it.
   window.__openhumanFeedPcm = function (b64) {
@@ -110,6 +137,13 @@
       var src = ctx.createBufferSource();
       src.buffer = buffer;
       src.connect(dest);
+      // Also pipe to the page's default audio output so the bot's
+      // TTS is audible on the host machine. This does NOT cause echo
+      // because Meet attributes the bot's own speech to "You" (which
+      // is filtered in core's note_caption) and the media-element
+      // mute below silences Meet's INCOMING call audio (other
+      // participants' voices bouncing back through speakers).
+      src.connect(ctx.destination);
       // Schedule strictly after the previous chunk so successive
       // 100 ms feeds line up gaplessly. If the queue has emptied
       // (caller fell behind), restart at currentTime so we don't try
@@ -118,6 +152,11 @@
         nextStartTime = ctx.currentTime;
       }
       src.start(nextStartTime);
+      activeSources.push(src);
+      src.onended = function () {
+        var idx = activeSources.indexOf(src);
+        if (idx !== -1) activeSources.splice(idx, 1);
+      };
       nextStartTime += buffer.duration;
       // High-frequency log gated by a counter so we don't drown the
       // console at 10 Hz; emit ~1 in 50 frames (~5 s cadence at the
@@ -231,5 +270,161 @@
         });
     };
   }
-  console.log("[openhuman-audio-bridge] install complete");
+  // Mute all inbound call audio on this page. The bot's CEF window is
+  // a headless participant — it reads captions for input and uses the
+  // virtual mic for output. Any audio that plays through the local
+  // speakers gets picked up by the user's mic (they're on the same
+  // machine) and causes an echo loop. We:
+  //
+  //   1. Mute all existing <audio> and <video> elements.
+  //   2. Observe the DOM for new media elements and mute those too.
+  //   3. Monkey-patch HTMLMediaElement.prototype.play to auto-mute
+  //      before playing, catching dynamically created elements that
+  //      aren't in the DOM yet.
+  //
+  // This does NOT affect the bridge's outbound TTS path — that goes
+  // through the Web Audio graph's MediaStreamDestination (virtual mic),
+  // not through any <audio>/<video> element.
+  function muteMediaElement(el) {
+    try {
+      el.muted = true;
+      el.volume = 0;
+    } catch (_) {}
+  }
+
+  function muteAllMedia() {
+    var els = document.querySelectorAll("audio, video");
+    for (var i = 0; i < els.length; i++) {
+      muteMediaElement(els[i]);
+    }
+  }
+
+  // Initial sweep (may be empty at document-start; the observer
+  // and play-patch handle late arrivals).
+  muteAllMedia();
+
+  // Observe DOM for dynamically added media elements.
+  try {
+    var mediaObserver = new MutationObserver(function (mutations) {
+      for (var i = 0; i < mutations.length; i++) {
+        var added = mutations[i].addedNodes;
+        for (var j = 0; j < added.length; j++) {
+          var node = added[j];
+          if (node.nodeType !== 1) continue;
+          if (node.tagName === "AUDIO" || node.tagName === "VIDEO") {
+            muteMediaElement(node);
+          }
+          // Also check children (e.g. a div containing a <video>).
+          if (node.querySelectorAll) {
+            var inner = node.querySelectorAll("audio, video");
+            for (var k = 0; k < inner.length; k++) {
+              muteMediaElement(inner[k]);
+            }
+          }
+        }
+      }
+    });
+    mediaObserver.observe(document.documentElement || document.body || document, {
+      childList: true,
+      subtree: true,
+    });
+  } catch (e) {
+    console.warn("[openhuman-audio-bridge] media mute observer failed:", e);
+  }
+
+  // Monkey-patch play() to ensure mute sticks even for elements created
+  // outside the DOM (Meet sometimes uses detached <audio> for WebRTC).
+  try {
+    var origPlay = HTMLMediaElement.prototype.play;
+    HTMLMediaElement.prototype.play = function () {
+      muteMediaElement(this);
+      return origPlay.apply(this, arguments);
+    };
+  } catch (e) {
+    console.warn("[openhuman-audio-bridge] play() patch failed:", e);
+  }
+
+  // WebRTC-level muting: Meet routes incoming participant audio via
+  // RTCPeerConnection.ontrack, NOT through <audio> elements. The DOM
+  // patches above miss this entirely. We intercept at two layers:
+  //
+  //   1. RTCPeerConnection.prototype.addTrack — no-op (we don't need
+  //      to touch outbound, only inbound).
+  //   2. Incoming remote audio tracks — disable them so the browser
+  //      never sends their samples to the speaker.
+  //   3. AudioContext.createMediaStreamSource — return a silent
+  //      (disconnected) source so any Web Audio routing of remote
+  //      streams produces no output.
+  //
+  // Our bridge's TTS path is unaffected because it uses
+  // AudioBufferSource → dest (MediaStreamDestination) + ctx.destination,
+  // never an RTCPeerConnection or createMediaStreamSource.
+  try {
+    var origRTCPeerConnection = window.RTCPeerConnection;
+    if (origRTCPeerConnection) {
+      // Intercept the ontrack setter to disable incoming audio tracks.
+      var origAddEventListener = origRTCPeerConnection.prototype.addEventListener;
+      origRTCPeerConnection.prototype.addEventListener = function (type, listener, options) {
+        if (type === "track") {
+          var wrappedListener = function (event) {
+            if (event.track && event.track.kind === "audio") {
+              event.track.enabled = false;
+              console.log("[openhuman-audio-bridge] disabled incoming WebRTC audio track");
+            }
+            return listener.call(this, event);
+          };
+          return origAddEventListener.call(this, type, wrappedListener, options);
+        }
+        return origAddEventListener.call(this, type, listener, options);
+      };
+
+      // Also intercept the ontrack property setter.
+      var ontrackDesc = Object.getOwnPropertyDescriptor(origRTCPeerConnection.prototype, "ontrack");
+      if (ontrackDesc && ontrackDesc.set) {
+        var origOntrackSet = ontrackDesc.set;
+        Object.defineProperty(origRTCPeerConnection.prototype, "ontrack", {
+          get: ontrackDesc.get,
+          set: function (handler) {
+            var wrapped = function (event) {
+              if (event.track && event.track.kind === "audio") {
+                event.track.enabled = false;
+                console.log("[openhuman-audio-bridge] disabled incoming WebRTC audio track (ontrack)");
+              }
+              return handler.call(this, event);
+            };
+            origOntrackSet.call(this, wrapped);
+          },
+          configurable: true,
+        });
+      }
+    }
+  } catch (e) {
+    console.warn("[openhuman-audio-bridge] RTCPeerConnection patch failed:", e);
+  }
+
+  // Intercept AudioContext.createMediaStreamSource so remote streams
+  // routed through Web Audio produce silence instead of speaker output.
+  try {
+    var origCreateMSS = AudioContext.prototype.createMediaStreamSource;
+    AudioContext.prototype.createMediaStreamSource = function (stream) {
+      var node = origCreateMSS.call(this, stream);
+      // Check if this is a remote stream (not our bridge's dest stream).
+      // Our bridge uses dest.stream which has a known track; anything
+      // else is remote audio we want to silence.
+      if (dest && stream === dest.stream) {
+        return node; // our bridge — pass through
+      }
+      // Remote stream — create a gain node set to 0 and interpose it
+      // so nothing reaches the destination.
+      var silencer = this.createGain();
+      silencer.gain.value = 0;
+      node.connect(silencer);
+      console.log("[openhuman-audio-bridge] silenced createMediaStreamSource (remote stream)");
+      return silencer;
+    };
+  } catch (e) {
+    console.warn("[openhuman-audio-bridge] createMediaStreamSource patch failed:", e);
+  }
+
+  console.log("[openhuman-audio-bridge] install complete (local audio + WebRTC muted)");
 })();

app/src-tauri/src/meet_audio/caption_listener.rs

@@ -32,6 +32,10 @@ const POLL_INTERVAL: Duration = Duration::from_millis(500);
 /// away (call ended) or the renderer crashed.
 const MAX_CONSECUTIVE_ERRORS: u32 = 30;
 
+/// How often (in ticks) to log a diagnostic heartbeat when drains are
+/// empty. 60 ticks × 500 ms = every 30 s.
+const DIAG_HEARTBEAT_TICKS: u64 = 60;
+
 /// RAII handle. Drop to stop the listener task.
 pub struct CaptionListener {
     pub request_id: String,
@@ -58,6 +62,11 @@ pub fn start(request_id: String, cdp: CdpConn, session_id: String) -> CaptionLis
         tick.tick().await;
         let mut cdp = cdp;
         let mut errors: u32 = 0;
+        let mut tick_count: u64 = 0;
+        let mut total_captions: u64 = 0;
+
+        log::info!("[meet-audio] caption listener started request_id={request_id_for_task}");
+
         loop {
             tokio::select! {
                 _ = &mut shutdown_rx => {
@@ -67,8 +76,12 @@ pub fn start(request_id: String, cdp: CdpConn, session_id: String) -> CaptionLis
                     break;
                 }
                 _ = tick.tick() => {
+                    tick_count += 1;
                     match drain_and_forward(&request_id_for_task, &mut cdp, &session_id).await {
-                        Ok(_) => errors = 0,
+                        Ok(count) => {
+                            errors = 0;
+                            total_captions += count;
+                        },
                         Err(err) => {
                             errors += 1;
                             log::debug!(
@@ -82,6 +95,17 @@ pub fn start(request_id: String, cdp: CdpConn, session_id: String) -> CaptionLis
                             }
                         }
                     }
+
+                    // Periodic diagnostic heartbeat so silent caption
+                    // listeners are visible in the logs.
+                    if tick_count % DIAG_HEARTBEAT_TICKS == 0 {
+                        let bridge_info = probe_bridge_info(&mut cdp, &session_id).await;
+                        log::info!(
+                            "[meet-audio] caption listener heartbeat request_id={request_id_for_task} \
+                             ticks={tick_count} total_captions={total_captions} \
+                             consec_errors={errors} bridge={bridge_info}"
+                        );
+                    }
                 }
             }
         }
@@ -93,19 +117,18 @@ pub fn start(request_id: String, cdp: CdpConn, session_id: String) -> CaptionLis
     }
 }
 
+/// Returns the number of captions forwarded to core.
 async fn drain_and_forward(
     request_id: &str,
     cdp: &mut CdpConn,
     session_id: &str,
-) -> Result<(), String> {
+) -> Result<u64, String> {
     let captions = inject::drain_captions(cdp, session_id).await?;
     if captions.is_empty() {
-        return Ok(());
+        return Ok(0);
     }
-    log::info!(
-        "[meet-audio] captions drained count={} request_id={request_id}",
-        captions.len()
-    );
+    let count = captions.len() as u64;
+    log::info!("[meet-audio] captions drained count={count} request_id={request_id}",);
     for (speaker, text, ts_ms) in captions {
         // Propagate the failure so MAX_CONSECUTIVE_ERRORS can trip if
         // core's session/RPC path is broken — without this the
@@ -123,5 +146,31 @@ async fn drain_and_forward(
         .await
         .map_err(|err| format!("push_caption (request_id={request_id}): {err}"))?;
     }
-    Ok(())
+    Ok(count)
+}
+
+/// Query the page-side captions bridge for diagnostic info. Never
+/// fails — returns a human-readable string for the heartbeat log.
+async fn probe_bridge_info(cdp: &mut CdpConn, session_id: &str) -> String {
+    let res = cdp
+        .call(
+            "Runtime.evaluate",
+            serde_json::json!({
+                "expression": "(typeof window.__openhumanCaptionsBridgeInfo === 'function') \
+                               ? JSON.stringify(window.__openhumanCaptionsBridgeInfo()) \
+                               : '{\"installed\":false}'",
+                "returnByValue": true,
+            }),
+            Some(session_id),
+        )
+        .await;
+    match res {
+        Ok(v) => v
+            .get("result")
+            .and_then(|r| r.get("value"))
+            .and_then(|v| v.as_str())
+            .unwrap_or("{\"error\":\"no value\"}")
+            .to_string(),
+        Err(err) => format!("{{\"error\":\"{err}\"}}"),
+    }
 }