test(voice): a demo flow, paced like a real call

The harness could already drive the loop; it could not be watched. Turns
arrived in the presenter as finished sentences appearing at machine speed,
which is the tell that a rig is driving it. `speak` publishes one turn id
growing a word at a time (~150 wpm), `beat` leaves a silence where a person
would hear one, and `stashAttachment` puts a photo on the bridge the way a
real capture does — so a recording of the harness reads as a recording of a
call. DemoFlowTest drives that end to end against a real model and a real
agent, behind SAI_DEMO=1 so CI never wakes a VM.

Also a real bug the demo surfaced: the turn end was always scheduled on the
virtual clock, but a live transport delivers on real time and nothing
advances the virtual one — so the turn never ended, `modelSpeaking` stayed
true, and every nudge deferred behind it. The model looked mute when it had
simply never been told anything. Same shape as the bug LiveTurnGate was
extracted for, and it spoiled a live demo before the cause was spotted.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: jamie-simular

meta-android-app/app/build.gradle.kts

@@ -199,13 +199,16 @@ tasks.withType<Test>().configureEach {
           // Mirroring a harness conversation to the presenter, so a test can be watched.
           "SAI_PRESENTER",
           "SAI_PRESENTER_PACE_MS",
+          // The demo flow, which drives a real agent from a real model.
+          "SAI_DEMO",
       )
       .forEach { name -> System.getenv(name)?.let { environment(name, it) } }
   // The eval's output IS its result — a scorecard, not an assertion count — so it has to reach the
   // terminal. Only while it is running: on the ordinary suite this would bury 285 tests in noise.
   // (A full run makes dozens of model calls and waits out per-minute rate limits between them, so it
   // takes minutes. Gradle sets no default test timeout, so there is nothing to raise.)
-  if (System.getenv("SAI_CONVERSATION_EVAL") == "1" || System.getenv("SAI_PRESENTER") == "1") {
+  if (System.getenv("SAI_CONVERSATION_EVAL") == "1" || System.getenv("SAI_PRESENTER") == "1" ||
+      System.getenv("SAI_DEMO") == "1") {
     testLogging { showStandardStreams = true }
   }
 }

meta-android-app/app/src/test/java/com/meta/wearable/dat/externalsampleapps/cameraaccess/saispike/conversation/ConversationHarness.kt

@@ -131,6 +131,19 @@ class ConversationHarness(
    */
   suspend fun deliverAgentEvent(event: AgentEvent) = onAgentEvent(event)
 
+  /**
+   * Leave a photo on the bridge for whatever writes next — what a real capture does when it lands.
+   *
+   * The stash belongs to the next write, which is exactly the immediate path's rule: the adapter
+   * drains it on `forwardTask`. A held task takes its photos with it instead (see
+   * `takePendingAttachments`), which is why a queued request cannot end up carrying someone else's.
+   */
+  fun stashAttachment(attachment: com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.fsm.TaskAttachment) =
+      bridge.addPendingAttachment(attachment)
+
+  /** Let the presenter show a beat of silence, when one is what a person would hear. */
+  fun beat(ms: Long) = presenter?.pause(ms)
+
   val concierge =
       Concierge(
           agent = bridge,
@@ -165,7 +178,7 @@ class ConversationHarness(
   suspend fun user(utterance: String) {
     lastUserSpeechAt = clock.now
     transcript += Line("you", utterance)
-    presenter?.turn("you", utterance)
+    presenter?.speak("you", utterance)
     gate.onUserTranscript(utterance)
     modelTurn(utterance)
   }
@@ -222,13 +235,26 @@ class ConversationHarness(
     if (!turn.speech.isNullOrBlank()) {
       runGate(gate.onSaiTranscript(turn.speech))
       transcript += Line("sai", turn.speech)
-      presenter?.turn("sai", turn.speech)
+      presenter?.speak("sai", turn.speech)
     }
     routeCalls(turn.calls)
     // The turn ends after the model has finished speaking, not instantly: the gap is the window in
     // which a completion landing mid-sentence is held, which is the race worth testing.
-    clock.scheduleSuspending(if (turn.speech.isNullOrBlank()) 0 else speakingMs) {
+    //
+    // WHICH clock matters, and getting it wrong is silent. A live transport delivers on real time and
+    // nothing advances the virtual one, so scheduling the turn end there meant it never fired:
+    // `modelSpeaking` stayed true for the rest of the call and every nudge was deferred behind a turn
+    // that would never end. The model looked mute when it had simply never been told anything — the
+    // same shape as the bug LiveTurnGate was extracted for, reproduced in the harness, and it spoiled
+    // a live demo before the cause was spotted.
+    val speakFor = if (turn.speech.isNullOrBlank()) 0L else speakingMs
+    if (transport != null) {
+      kotlinx.coroutines.delay(speakFor)
       runGate(gate.onGenerationOrTurnEnd(generationEnded = false, turnEnded = true))
+    } else {
+      clock.scheduleSuspending(speakFor) {
+        runGate(gate.onGenerationOrTurnEnd(generationEnded = false, turnEnded = true))
+      }
     }
   }
 

meta-android-app/app/src/test/java/com/meta/wearable/dat/externalsampleapps/cameraaccess/saispike/conversation/DemoFlowTest.kt

@@ -0,0 +1,177 @@
+/* sai-fi — voice concierge. */
+
+// The demo flow: ONE call, the real model, a real agent, mirrored to the presenter.
+//
+//   SAI_DEMO=1 SAI_PRESENTER=1 GEMINI_API_KEY=… \
+//   SAI_CONCIERGE_URL=… SAI_MACHINE_ID=… SAI_ID_TOKEN=… \
+//     ./gradlew :app:testDebugUnitTest --tests "*DemoFlowTest*" --rerun
+//
+// Everything is real except the microphone and the camera: the model is Gemini running the prompt
+// and tools the app ships, the FSM is the app's, the bridge and its wire are the app's, and the
+// agent is a real machine doing real work. What is stood in for is the audio — the user's turns are
+// injected as text at speaking pace — and the glasses camera, which uploads a labelled frame through
+// the real upload endpoint.
+//
+// **One call, not a series.** Each beat depends on the state the last one left: a task is queued only
+// because another is running, the status question is only interesting with two things outstanding,
+// and the goodbye only tests anything with work still in flight. Restarting between beats would
+// destroy the very thing being shown, and it is also how a demo ends up proving less than it appears
+// to — every step passing in isolation while the sequence has never once been run end to end.
+//
+// Paced for watching, not for speed. The user's lines stream in at ordinary speech (~150 wpm) rather
+// than appearing whole, because a line that lands complete and instantly is the tell that a rig is
+// driving it.
+
+package com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.conversation
+
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.eval.LiveBrain
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+
+class DemoFlowTest {
+
+  private val apiKey = System.getenv("GEMINI_API_KEY") ?: System.getenv("GOOGLE_API_KEY") ?: ""
+  private val model = System.getenv("EVAL_MODEL") ?: "gemini-3-flash-preview"
+
+  @Test
+  fun `the glasses demo, one conversation, live agent`() {
+    assumeTrue("set SAI_DEMO=1 to run the demo flow (it drives a real agent)", System.getenv("SAI_DEMO") == "1")
+    assumeTrue("set GEMINI_API_KEY", apiKey.isNotEmpty())
+    val config = LiveAgentConfig.fromEnv().getOrElse { throw IllegalStateException(it.message, it) }
+
+    val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    lateinit var h: ConversationHarness
+
+    val brain =
+        LiveBrain(
+            apiKey = apiKey,
+            model = model,
+            resolveLocalTool = { name, _ ->
+              when (name) {
+                "getSaiStatus" -> JSONObject().put("status", h.status())
+                // The camera. Uploads the frame and leaves it on the bridge, so the next forward
+                // carries it exactly as a real capture would — the immediate path drains the stash.
+                "captureImage" ->
+                    runBlocking {
+                      runCatching {
+                            val a = DummyCamera.capture(config.baseUrl, config.idToken)
+                            h.stashAttachment(a)
+                            println("    [camera] uploaded a simulated frame (${a.name})")
+                            JSONObject()
+                                .put("result", "captured")
+                                .put(
+                                    "note",
+                                    "The photo is saved on the device and has NOT been sent " +
+                                        "anywhere; it goes only when a request carries it.")
+                          }
+                          .getOrElse {
+                            JSONObject().put("result", "failed").put("error", it.message ?: "camera error")
+                          }
+                    }
+                else -> JSONObject().put("result", "ok")
+              }
+            },
+            log = { println("    $it") },
+        )
+
+    h = ConversationHarness(brain, speakingMs = 600)
+    val live =
+        LiveAgent(config, scope, deliver = { h.deliverAgentEvent(it) }, log = { println("    $it") })
+    h.useTransport(live)
+
+    runBlocking {
+      h.start()
+      h.beat(1_500)
+
+      // 1 — the greeting. Sai speaks first, unprompted, exactly as it does when a call opens.
+      say(h, "Hey Sai, are you there?")
+      settle(h, live, 6_000)
+
+      // 2 — a real task on a real machine, and the approval it trips.
+      //
+      //     The first run of this demo had no approval beat, and it distorted everything after it:
+      //     the listing tripped a guardrail, Sai asked "would you like me to approve that?", the
+      //     script ignored the question and moved on, and the task sat blocked while the rest of the
+      //     conversation talked around a result that never came. A demo that cannot answer a
+      //     guardrail cannot show a task finishing.
+      say(h, "Can you check what's in my downloads folder?")
+      settle(h, live, 45_000)
+      answerAnyApproval(h, live)
+
+      // 3 — a second ask while the first is still going. This is the queue, and it only exists
+      //     because beat 2 left something running.
+      say(h, "Oh, and also — what time is it right now?")
+      h.beat(2_000)
+
+      // 4 — with two outstanding, ask what is happening. The interesting part is that they are
+      //     accounted for separately.
+      say(h, "What's going on with all that?")
+      settle(h, live, 45_000)
+
+      // 5 — the camera.
+      say(h, "Have a look at this and tell me what it says.")
+      settle(h, live, 45_000)
+
+      // 6 — barge-in, mid-answer.
+      h.beat(800)
+      bargeIn(h, "Sorry — actually, what can you do for me?")
+      settle(h, live, 20_000)
+
+      // 7 — the goodbye.
+      say(h, "That's everything, thanks — bye.")
+      settle(h, live, 15_000)
+
+      println("\n=== the conversation ===")
+      h.transcript.forEach { println("  ${it.speaker.padEnd(6)} ${it.text}") }
+      println("\n=== what the agent ran ===")
+      live.started.forEach { println("  • $it") }
+      println("\nevents off the wire: ${live.received.map { it::class.simpleName }}")
+      if (live.errors.isNotEmpty()) println("errors: ${live.errors}")
+    }
+  }
+
+  /**
+   * If the agent is waiting on a guardrail, answer it the way a wearer would.
+   *
+   * Checked rather than scripted blind: whether a given task trips an approval depends on the
+   * machine's settings, so a fixed "yes, go ahead" beat would be an answer to nothing on a machine
+   * with guardrails off — and the model, told yes for no reason, has to invent what it is agreeing to.
+   */
+  private suspend fun answerAnyApproval(h: ConversationHarness, live: LiveAgent) {
+    if (h.state.pendingApprovalId == null) {
+      println("    (no approval was raised — nothing to answer)")
+      return
+    }
+    say(h, "Yes, go ahead — you have my approval.")
+    settle(h, live, 60_000)
+  }
+
+  /** A user turn, at speaking pace, with a breath before it. */
+  private suspend fun say(h: ConversationHarness, line: String) {
+    h.beat(900)
+    println("\n>>> $line")
+    h.user(line)
+  }
+
+  private suspend fun bargeIn(h: ConversationHarness, line: String) {
+    println("\n>>> (cutting in) $line")
+    h.bargeIn(line)
+  }
+
+  /**
+   * Let the agent get on with it.
+   *
+   * Real time, not the virtual clock: a live agent takes as long as it takes, and the demo is
+   * watchable precisely because those pauses are real. Bounded so a cold machine cannot hang the run.
+   */
+  private suspend fun settle(h: ConversationHarness, live: LiveAgent, budgetMs: Long) {
+    withTimeoutOrNull(budgetMs) { live.awaitTurn() }
+    h.beat(1_200)
+  }
+}

meta-android-app/app/src/test/java/com/meta/wearable/dat/externalsampleapps/cameraaccess/saispike/conversation/DummyCamera.kt

@@ -0,0 +1,49 @@
+/* sai-fi — voice concierge. */
+
+// A glasses camera, without glasses.
+//
+// The camera is the one part of a call a scripted double cannot stand in for, because the photo has
+// to physically EXIST somewhere the agent can fetch it: the device uploads it and the task carries a
+// reference. So this puts a real JPEG through the real `/v1/agents/upload` and leaves the real
+// attachment on the bridge. From the agent's side it is indistinguishable from a glasses photo —
+// only the photons are fake.
+//
+// The frame is a committed resource rather than something drawn here: Android unit tests compile
+// against `android.jar`, which has no `java.awt` and no `javax.imageio`, so there is nothing to draw
+// with. It was generated on a Mac (see the PR) and says SIMULATED CAPTURE across the bottom, because
+// a demo recording showing a photograph invites the question "did that really come off the glasses?"
+// and a frame that answers it on its face cannot mislead anyone watching.
+
+package com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.conversation
+
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.ConciergeClient
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.fsm.TaskAttachment
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.toTaskAttachment
+
+object DummyCamera {
+
+  const val WIDTH = 1024
+  const val HEIGHT = 768
+
+  /** What the frame depicts, so a scenario can check the answer against something knowable. */
+  const val DEPICTS = "A red notebook and a coffee mug"
+
+  fun frame(): ByteArray =
+      checkNotNull(DummyCamera::class.java.getResourceAsStream("/capture/simulated-capture.jpg")) {
+            "missing /capture/simulated-capture.jpg — the simulated glasses frame"
+          }
+          .use { it.readBytes() }
+
+  /**
+   * Take the frame, upload it, and hand back the attachment the next forward should carry.
+   *
+   * Same endpoint and same shape as the device's own path, including the width and height the
+   * uploader adds afterwards — the server does not measure the image, so a client that omits them
+   * leaves the agent guessing at the aspect ratio.
+   */
+  suspend fun capture(baseUrl: String, bearerToken: String): TaskAttachment =
+      ConciergeClient.uploadAttachment(baseUrl, bearerToken, frame(), "glasses.jpg")
+          .put("width", WIDTH)
+          .put("height", HEIGHT)
+          .toTaskAttachment()
+}

meta-android-app/app/src/test/java/com/meta/wearable/dat/externalsampleapps/cameraaccess/saispike/conversation/PresenterPublisher.kt

@@ -67,6 +67,36 @@ class PresenterPublisher(url: String, private val paceMs: Long) {
   fun turn(role: String, text: String) =
       send(JSONObject().put("t", "turn").put("id", nextId++).put("role", role).put("text", text))
 
+  /**
+   * Publish a turn the way a real one arrives: one id, growing a word at a time.
+   *
+   * A real call's transcript is a stream of deltas, so the presenter renders a line filling in as it
+   * is spoken. Publishing a finished sentence in a single frame is the tell that a rig is driving it
+   * — the words appear all at once, at machine speed, and no one is fooled. This paces at ordinary
+   * speech (~150 wpm by default) so a recording of the harness looks like a recording of a call.
+   *
+   * Deliberately not pretending to be a perfect impression: the delta boundaries here are words,
+   * whereas a real model streams whatever chunk the API hands over. What matters is the cadence.
+   */
+  fun speak(role: String, text: String, wordsPerMinute: Int = 150) {
+    val id = nextId++
+    val words = text.split(' ').filter { it.isNotEmpty() }
+    if (words.isEmpty()) return
+    val perWord = (60_000L / wordsPerMinute).coerceAtLeast(1)
+    val sb = StringBuilder()
+    for ((i, w) in words.withIndex()) {
+      if (i > 0) sb.append(' ')
+      sb.append(w)
+      ws?.send(JSONObject().put("t", "turn").put("id", id).put("role", role).put("text", sb.toString()).toString())
+      // A touch longer after a comma or a full stop, which is where a speaker actually breathes.
+      val pause = if (w.endsWith(",") || w.endsWith(".") || w.endsWith("?")) perWord * 2 else perWord
+      Thread.sleep(pause)
+    }
+  }
+
+  /** A silence, for the gaps a conversation actually has. */
+  fun pause(ms: Long) = Thread.sleep(ms)
+
   fun log(text: String) =
       send(JSONObject().put("t", "log").put("id", nextId++).put("text", text))
 

meta-android-app/app/src/test/java/com/meta/wearable/dat/externalsampleapps/cameraaccess/saispike/conversation/SummaryFixLiveTest.kt

@@ -0,0 +1,56 @@
+/* sai-fi — voice concierge. TEMPORARY live verification of the finish-summary fix. */
+package com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.conversation
+
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.conversation.ScriptedBrain.Companion.whenNudged
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.conversation.ScriptedBrain.Companion.whenSaid
+import com.meta.wearable.dat.externalsampleapps.cameraaccess.saispike.fsm.AgentEvent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+
+class SummaryFixLiveTest {
+  @Test
+  fun `a real task that answers in text deltas is actually reported to the user`() {
+    assumeTrue(System.getenv("SAI_LIVE_AGENT") == "1")
+    val config = LiveAgentConfig.fromEnv().getOrElse { throw IllegalStateException(it.message, it) }
+    val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    val task = "reply with exactly the words banana pancakes, do not use any tools"
+
+    val brain =
+        ScriptedBrain.of(
+            whenSaid("banana") { _, _ -> BrainTurn("on it", callsOf(fc("forwardToAgent", "text" to task))) },
+            // Relay whatever the completion nudge carries — which, before the fix, was an
+            // instruction to say nothing came back.
+            whenNudged("[agent]") { input, _ -> BrainTurn("the agent says: $input") },
+        )
+
+    runBlocking {
+      val h = ConversationHarness(brain)
+      val live = LiveAgent(config, scope, deliver = { h.deliverAgentEvent(it) }, log = { println("    $it") })
+      h.useTransport(live)
+      h.start()
+      h.user(task)
+      withTimeoutOrNull(120_000) { live.awaitTurn() }
+
+      val completes = live.received.filterIsInstance<AgentEvent.Complete>()
+      println("\n=== events: ${live.received.map { it::class.simpleName }}")
+      println("=== complete.summary: ${completes.map { it.summary }}")
+      println("=== heard: ${h.heard()}")
+      if (live.errors.isNotEmpty()) println("=== errors: ${live.errors}")
+
+      assertTrue("nothing was refused: ${live.errors}", live.errors.isEmpty())
+      assertTrue("a completion arrived", completes.isNotEmpty())
+      assertTrue(
+          "THE FIX: the completion must carry the agent's answer, not an empty summary — got ${completes.map { it.summary }}",
+          completes.any { !it.summary.isNullOrBlank() })
+      assertTrue(
+          "and the concierge must NOT have been told nothing came back: ${h.heard()}",
+          !h.heard().contains("without reporting"))
+    }
+  }
+}