feat(meet-agent): Flow A second brain — orchestrator + tools + pre-roll + cache + barge-in

app/src-tauri/src/lib.rs

@@ -2989,6 +2989,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

@@ -97,6 +97,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 +133,16 @@
       var src = ctx.createBufferSource();
       src.buffer = buffer;
       src.connect(dest);
+      // Also pipe to the page's default audio output so the bot is
+      // audible on the host machine (the openhuman app's speakers).
+      // Without this, bot audio only flows up Meet's gUM intercept
+      // and the user has to be receiving the meeting on a separate
+      // endpoint (other browser tab / phone) to hear it. Playing
+      // locally too costs nothing audio-quality-wise and removes the
+      // "captions appear but no sound" foot-gun. Follow-up #20
+      // (mute bot CEF at OS level) will re-introduce a clean off
+      // switch once we have a config toggle.
+      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 +151,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

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

@@ -139,18 +139,35 @@
   }
 
   // Auto-enable captions: walk every button on the page and click any
-  // that has an aria-label starting with "Turn on captions". Caps the
-  // attempts so we don't fight a user who deliberately disables CC.
-  var ENABLE_ATTEMPT_BUDGET = 30; // ~30 * 2s = 60s
+  // that has an aria-label matching the "turn on captions" intent.
+  // Substring match (not prefix) — Meet rolls out variant labels
+  // ("Turn on captions (c)", "Turn on live captions", "Subtitles",
+  // "Captions") that the strict prefix-only matcher missed, forcing
+  // the user to click the toggle by hand. Caps attempts so a user who
+  // deliberately disables CC isn't fought over forever.
+  var ENABLE_ATTEMPT_BUDGET = 60; // ~60 * 2s = 120s — covers slow admit
   var enableAttempts = 0;
   function tryEnableCaptions() {
     if (enableAttempts >= ENABLE_ATTEMPT_BUDGET) return;
     enableAttempts++;
     var buttons = document.querySelectorAll("button[aria-label]");
+    var ON_PATTERNS = [
+      "turn on captions",
+      "turn on live captions",
+      "turn on subtitles",
+      "turn on closed captions",
+      "captions on",
+      "captions (c)",
+      "show captions",
+      "enable captions",
+    ];
+    // Negative guard: never click anything that is already-on (Meet
+    // shows "Turn off captions" when CC is active).
+    var OFF_PATTERNS = ["turn off captions", "captions off", "disable captions"];
     for (var i = 0; i < buttons.length; i++) {
       var lbl = (buttons[i].getAttribute("aria-label") || "").toLowerCase();
-      // Match "Turn on captions" but NOT "Turn off captions".
-      if (lbl.indexOf("turn on captions") === 0 || /^turn on captions/.test(lbl)) {
+      if (OFF_PATTERNS.some(function (p) { return lbl.indexOf(p) >= 0; })) continue;
+      if (ON_PATTERNS.some(function (p) { return lbl.indexOf(p) >= 0; })) {
         try {
           buttons[i].click();
           enableAttempts = ENABLE_ATTEMPT_BUDGET; // success — stop trying.

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

@@ -274,3 +274,31 @@ pub async fn feed_pcm_chunk(cdp: &mut CdpConn, session: &str, pcm_b64: &str) ->
     }
     Ok(())
 }
+
+/// Stop any in-flight audio playback inside the page bridge and reset
+/// its schedule cursor. Called when the brain cancels outbound (user
+/// re-asks during a long reply) so the previous reply's tail doesn't
+/// keep playing while the new turn is dispatched. Returns the count
+/// of sources that were stopped, useful for diagnostic logging.
+pub async fn flush_audio_bridge(cdp: &mut CdpConn, session: &str) -> Result<i64, String> {
+    let res = cdp
+        .call(
+            "Runtime.evaluate",
+            json!({
+                "expression": "(typeof window.__openhumanFlushAudio === 'function') ? window.__openhumanFlushAudio() : -1",
+                "returnByValue": true,
+            }),
+            Some(session),
+        )
+        .await
+        .map_err(|e| format!("Runtime.evaluate flush: {e}"))?;
+    if let Some(exception) = res.get("exceptionDetails") {
+        return Err(format!("page exception: {exception}"));
+    }
+    let stopped = res
+        .get("result")
+        .and_then(|r| r.get("value"))
+        .and_then(|v| v.as_i64())
+        .unwrap_or(0);
+    Ok(stopped)
+}

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

@@ -87,10 +87,15 @@ pub async fn start<R: Runtime>(
     app: AppHandle<R>,
     request_id: String,
     meet_url: String,
+    owner_display_name: String,
+    bot_display_name: String,
 ) -> Result<(), String> {
     log::info!(
-        "[meet-audio] start request_id={request_id} url_prefix={}",
-        truncate_for_log(&meet_url, 64)
+        "[meet-audio] start request_id={request_id} url_prefix={} \
+         owner_chars={} bot_chars={}",
+        truncate_for_log(&meet_url, 64),
+        owner_display_name.chars().count(),
+        bot_display_name.chars().count()
     );
 
     if let Some(state) = app.try_state::<MeetAudioState>() {
@@ -104,12 +109,22 @@ pub async fn start<R: Runtime>(
     }
 
     // Tell core to open its session first so the very first PCM push
-    // doesn't race the start RPC.
+    // doesn't race the start RPC. Hand the call owner + bot display
+    // names through with the request so the core wake-word gate
+    // (privacy lock: only the owner can trigger tool calls) is
+    // active before the first caption can arrive.
     rpc_call(
         "openhuman.meet_agent_start_session",
         serde_json::json!({
             "request_id": request_id,
             "sample_rate_hz": 16_000,
+            "owner_display_name": owner_display_name,
+            "bot_display_name": bot_display_name,
+            // Persisted into the recent-calls JSONL by stop_session
+            // so the Skills "Meeting Bots" card can show "joined
+            // <code>" in the history list. The URL the shell built
+            // the CEF window with is the canonical value.
+            "meet_url": meet_url,
         }),
     )
     .await?;
@@ -170,7 +185,7 @@ pub async fn start<R: Runtime>(
                     caption_listener_disabled(request_id.clone())
                 }
             };
-            let speak = speak_pump::start(request_id.clone(), cdp, session);
+            let speak = speak_pump::start(app.clone(), request_id.clone(), cdp, session);
             (speak, captions)
         }
         Err(err) => {