Merge branch 'main' into feat/cctv-vegvesen-kartverket-heights

.env.example

@@ -83,6 +83,12 @@ OPENAI_REALTIME_TRANSCRIBE_MODEL=gpt-4o-mini-transcribe
 # keep them while debugging; delete the log when you are done.
 GEV_VOICE_LOG_CONTENT=
 OPENAI_HUD_SUMMARY_MODEL=gpt-5-nano
+# Optional: Gemini Live voice, selected in the GEV MIC provider chooser.
+# Server-only key. Do not prefix with VITE_. Provider Settings can save it.
+GEMINI_API_KEY=
+GEMINI_LIVE_MODEL=gemini-3.8-live
+# Token starts per IP per minute; 0 disables the throttle, not provider quotas.
+# GEV_RATELIMIT_GEMINI_PER_MIN=30
 # Per-IP rate limit for the OpenAI cost endpoints
 # (/api/realtime/token + /api/openai/hud-summary), in requests per minute.
 # DEFAULTS TO 30, the value the Pinokio build also ships. That clears ordinary

README.md

@@ -309,6 +309,10 @@ _Why cockpit mode exists: you're riding a real aircraft over real terrain — an
 
 ## 🎙️ Talk to It
 
+The standalone app offers **OpenAI** and **Gemini** in the GEV MIC provider chooser. OpenAI is the initial default; your choice is saved in this browser. To use Gemini, add `GEMINI_API_KEY` in Provider Settings or your local `.env` file, then select Gemini. `GEMINI_LIVE_MODEL` defaults to `gemini-3.8-live`. The permanent key stays on the local server, which issues a constrained, single-use session credential.
+
+Changing provider ends the current conversation. If voice is on, the new provider starts with the same open-mic or push-to-talk mode; a held Space key is not carried over. Gemini uses the same map actions and captions, but has no OpenAI cost meter or MINI tier. When Gemini reports that its session has expired, start voice again for a new conversation. The provider chooser does not change the OpenAI-backed AI HUD summary.
+
 > Voice can use an **OpenAI API key** or, on the same machine, an opt-in signed-in **ChatGPT/Codex OAuth** session. The API-key path remains the default. Selecting ChatGPT OAuth in Provider Settings reuses an existing local sign-in or starts the Codex browser sign-in flow and selects OAuth when it completes. The OpenAI key still drives the **AI HUD summary**: a terse, five-word intelligence-style readout of the current view that regenerates as you move.
 
 The OAuth option is experimental. OpenAI documents ChatGPT plan usage for the [Responses API](https://developers.openai.com/siwc/token-sharing-open-source/models-and-inference); a supported third-party Realtime contract for reusing Codex tokens has not been confirmed. A successful token mint does not establish billing or support terms.

changelog.d/1200-cctv-live-icon-color.md

@@ -0,0 +1,5 @@
+- Color CCTV cameras with a video feed violet. Cameras with an HLS, MP4 or
+  WebM feed were the same cyan as stills, so a DelDOT or Statens vegvesen
+  video camera could only be found by opening it. Stills stay cyan and the
+  active camera stays amber, and focus de-emphasis fades the violet the same
+  way (Danielslay86, #1200).

changelog.d/1201-cctv-stills-aspect.md

@@ -0,0 +1,4 @@
+- Draw CCTV stills at their source aspect on the monitor plane instead of
+  stretching them to the 16:9 canvas. Most DOT cameras publish 4:3 frames, so
+  every still was widened; they are now centered and pillarboxed on the dark
+  the placeholder already ends on (Danielslay86, #1201).

changelog.d/1220-openai-typed-send.md

@@ -0,0 +1,3 @@
+- Avoid starting or queuing a reply when the local channel rejects a typed OpenAI
+  command, while preserving an earlier accepted deferred input
+  (Manjunath, #1220).

changelog.d/1234-cctv-catalog-background-refresh.md

@@ -0,0 +1,5 @@
+- Serve the camera catalog while it refreshes. An expired catalog made every
+  camera request wait for the slowest pack to reload; it is now answered at
+  once while one background refresh runs, so only the first load waits. Estonia's
+  slow Tarktee feeds get 30 s instead of 15 s, so the pack no longer drops out
+  on about a third of loads (quanticsoul4772, #1234).

changelog.d/816-radio-owner-restoration.md

@@ -0,0 +1,7 @@
+- Close the compact Radio disclosure when an adaptive tactical right-rail
+  restore directly expands Context, before Space Missions can be covered.
+  A repeated Context-open request also clears stale disclosure state.
+  Real PanelChrome constructor wiring and the rail reflow path are covered
+  by focused regressions. Credits: kvnloo (#816), raysung-2026's original
+  #804 report, asturksever's review, and quanticsoul4772's independent
+  Windows diagnosis.

changelog.d/872-gemini-live-voice.md

@@ -0,0 +1,4 @@
+- Add optional Gemini Live voice to the standalone app, with a provider chooser,
+  server-held API key, microphone streaming, shared map actions and captions.
+  Switching providers ends the old conversation and preserves the input mode
+  (Manjunath, #872).

changelog.d/880-world-packet-boundary.md

@@ -0,0 +1,6 @@
+- Extract a reusable model-free World Packet from the existing voice
+  `get_current_view_state` owner without restoring disabled layers to the
+  model context. Keep the enabled-only payload, disabled-layer count, source
+  provenance, action result and view-state contract; read the layer roster once
+  per packet; voice retains the speech/card envelope at its own boundary.
+  Credits: original GEV voice/layer contributors and #880 implementation.

docs/CURRENT-STATE.md

@@ -496,6 +496,11 @@ to layer toggles, fly_to_location, frame_overhead, select_nearest_aircraft,
 get_entity_context, annotate_map and analyst_query. Analyst speech and the card
 share one deterministic count/scope headline; lower bounds use "At least" and
 partial answers name the unanswered layers. `get_current_view_state` lists enabled layers only.
+The model-free `gods-eye-view/agent/world-packet` export exposes
+`getWorldPacket({ viewer, styleManager, dataManager, sceneDirector })` to
+non-voice consumers. It reads the same enabled-only state and feed
+provenance before voice adds speech/card fields, with no new network requests
+or mutations.
 The voice card nested in the mic control (`voiceCard.js`) shows captions, plan
 steps and the result. `resultDisplay.js` is the one adapter from a result to
 the card: builder results show as built, and analyst results show a title
@@ -613,7 +618,9 @@ Reference feed construction is exported through `sources/reference`; the cable s
 
 Source factories have dedicated `layers/<family>/source` exports. ALPR and earthquake record normalization and CCTV source policy no longer pull rendering into source consumers. Catalog construction and voice feed reads use their focused owners; compatibility entries remain available. Settings filesystem hardening lives under `server/standalone/`. Import-direction checks complement export ownership checks; source behavior, settings policy and rendering are unchanged.
 
-Voice controls bind to a protocol-independent session factory. The default WebRTC adapter preserves the existing Realtime connection, push-to-talk, cost controls and radio handoff. Session subscriptions expose state, transcript, action call/progress/result, interruption, completion and turn-metrics events; stopping or replacing a session cancels pending actions. Alternate adapters can use the same controls and action runner.
+Voice controls bind to a protocol-independent session factory. The default WebRTC adapter preserves the existing Realtime connection, push-to-talk, cost controls and radio handoff. Session subscriptions expose state, transcript, action call/progress/result, interruption, completion and turn-metrics events; stopping or replacing a session cancels pending actions. An active session's normal Stop publishes one idle transition, including adapters that emit their own terminal state; a restart triggered by that transition keeps ownership of its new startup state. Alternate adapters can use the same controls and action runner.
+
+The standalone app offers OpenAI and Gemini Live through an explicit provider chooser. Gemini keeps its permanent API key on the local server and mints a short-lived, single-use credential with server-owned instructions and the standalone action catalog. Its native WebSocket adapter supports open microphone and push-to-talk input, streaming audio, captions and the existing action runner. In push-to-talk, a tool call that arrives with no input, reply or tool result outstanding is answered with a failure and never runs, and neither does any other call in the reply it starts; open-microphone turns start on Gemini's server-side activity detection, which reports no boundary to check. Switching providers ends the old conversation and releases its microphone and connection; only the input mode carries over. Gemini uses bounded shutdown draining and explicit manual restart, without automatic reconnection or a promise of uninterrupted session duration. Hosts that do not opt into the provider facade retain their existing default or custom adapter.
 
 Voice action argument schemas have one portable owner under `src/voice/actionSchemas.js`. The Realtime provider builds 30 tools using separate description-only metadata. Description customization cannot replace argument types, enum values or required fields.
 
@@ -1203,6 +1210,10 @@ Automatic collapse remains presentation only, prioritizes the latest explicit
 panel, and honors keyboard focus on the right. Mobile layout still releases
 desktop allocation styles. Stable Display allocation avoids unnecessary style
 writes. This extraction does not change panel positions or layout defaults.
+Context expansion through the panel owner or adaptive right-rail restoration
+closes an open compact Radio disclosure before Context/Space Missions becomes
+visible. The mini remains available while Context is collapsed. This fixes the
+Radio-overlap path reported in #804 without changing z-index or layout policy.
 The right rail skips panels hidden by other CSS (computed `display: none`), but
 keeps the collapsed panels its own exclusive presentation hides, so automatic
 collapse can still be undone.
@@ -4408,7 +4419,7 @@ silently demoting every later lookup for the session.
 - **FIRMS**: no ground clamping (zero 3D-tiles height sampling), ≤18 screen-decluttered ambient labels, click-to-inspect detail card, 2.5k/3k sprite budgets viewport-clipped by FRP.
 - **CCTV v2 foundation:** a pitched
   frustum wireframe (4 corner rays + far-cap rectangle) with a monitor plane at the frustum's
-  far cap, retargeting the existing video/canvas texture pipeline. Manual calibration only —
+  far cap, retargeting the existing video/canvas texture pipeline. Stills are drawn at their source aspect, centered on the placeholder dark (`#01070c`), instead of being stretched to the 16:9 canvas. Manual calibration only —
   auto-calibration and the drape mesh pipeline are deleted. A one-shot activation obstruction
   probe (`pickFromRay` on camera activation, clamping the plane short of the first hit) remains;
   ground placement is superseded by the shared-floor v3 behavior below. Calibration persists to
@@ -4426,7 +4437,7 @@ silently demoting every later lookup for the session.
   ground clamp now lifts the cap _center_ only so the wireframe stays a true pyramid welded to
   the plane (was a flattened fan / the ~47.5 m divergence — RESOLVED), re-selecting the active
   camera is a no-op (killed a click-flash), and texture swaps gate on canvas content (killed a
-  periodic white flash). Coverage is now **metro-wide: 250 cameras** (`CCTV_AUSTIN_MAX_SOURCES`
+  periodic white flash). Camera icons are cyan for stills, violet for cameras with a video feed, and amber for the active camera. Coverage is now **metro-wide: 250 cameras** (`CCTV_AUSTIN_MAX_SOURCES`
   default 36 → 250, hard bound 300), filtered to `camera_status === TURNED_ON` (~815 live of
   1,003 rows). City packs (2026-07-04): Caltrans (districts 4/7/11/3 — SF, LA, San Diego,
   Sacramento; cap 300) and TfL London JamCams (cap 250) join Austin (cap 250) as keyless default
@@ -4439,7 +4450,13 @@ silently demoting every later lookup for the session.
   GATHERING stations carry 2,256 in-collection presets, prioritized to 300 against seven anchors
   on the main road spine. `CCTV_MAX_SOURCES` is a 4,000 catalog-wide ceiling shared round-robin
   across packs, so a lower global cap thins every region instead of starving the last pack.
-  ~1,100 cameras total, all RAW PRIOR poses, stills-first.
+  ~1,100 cameras total, all RAW PRIOR poses, stills-first. The catalog lives for 15 minutes; once
+  it expires, `/api/cctv` keeps answering from it while one background refresh reloads every
+  pack, so only the very first load waits for the slowest pack (a live first load took about
+  22 s, and is bounded by Tarktee's 30 s). A background refresh that fails or comes back
+  empty keeps the old catalog and is retried after another 15 minutes, not on the next
+  request. Estonia's Tarktee DATEX feeds, which answer in 2 to 16.6 s, get 30 s
+  (`TARKTEE_FETCH_TIMEOUT_MS`) where other packs get 15 s.
 - **CCTV v3 UX — viewshed + calibration gizmo** (built 2026-07-05 and field
   validated 2026-07-21): the COVERAGE toggle is a
   tri-state cycle `OFF → ON → VIEWSHED`; viewshed mode renders each visible camera's frustum
@@ -4756,7 +4773,7 @@ and unreachable upstream (502/504) separately from road geometry.
   - **Every selectable layer writes that one slot** (2026-08-21). The tracking layers — flights, military, satellites — publish selection on their own awareness lane (`gev:awareness-subject-selected`, consumed by the readout card and the Contacts panel) and for the life of the voice tools never wrote the shared slot, so `scope:'selected'` silently answered `in_view` with a contact plainly selected on screen. They now call `selectTrackedSubjectContext` / `refreshTrackedSubjectContext` / `clearTrackedSubjectContext` (`src/data/contextStore.js`) on select / poll / deselect. **Invariants: (a)** that write path must NOT dispatch `gev:entity-selected` — tracking layers already own an event lane and a second one makes two surfaces fight over one subject; **(b)** exactly one record per tracking layer, because a frozen snapshot of a moved contact must never reach the visible-entity scan; **(c)** precedence is recency, not layer — one slot, last selection wins, so clicking an overlay entity supersedes a tracked plane as the voice subject while the plane stays tracked. Satellites refresh on the 1 s propagation beat, not per frame.
   - **Context-mode vocabulary is symmetric** (2026-08-21). `set_context_mode` accepts `contacts`; the internal id is `flights`. Every model-readable field (`mode`, `entering`, `priorMode`, nested `context`/`contextRollback`, and the transition diagnostic text) is reported in the accepted vocabulary, with the internal id preserved as `<field>Internal`; an absent secondary mode stays `null` rather than claiming to be `off`. Mapping lives in `src/contextModePolicy.js` so UI text and voice payloads cannot drift. Reporting the internal id made the model read `mode:'flights'` as "Contacts is off" and refuse to answer from the `contactsWindow` counts in the same payload.
   - **Analyst → track handoff carries a key, not just a label** (2026-08-21). `analyst_query` items include `icao24`/`mmsi` alongside the display `id`, and contact lookup uses the shared tiered ranking in `src/data/contactMatch.js`: hex exact → callsign exact → registration exact → callsign prefix → registration prefix → callsign substring → registration substring. The tiers keep an exact callsign ahead of a colliding registration regardless of feed order, and registrations compare separator-insensitively (`G-ABCD`/`GABCD`, `05-8152`/`058152`, `N123AB`/`N-123AB`).
-  - **A typed command supersedes the turn it interrupts** (2026-08-21). `sendTextCommand` defers its `response.create` behind an active response instead of colliding with it, marks that response superseded so a late function call from it is refused rather than dispatched, and drops the old turn's queued follow-up. A refused call is still ANSWERED — a terminal `{ok:false, superseded:true}` `function_call_output` — because an unanswered `function_call` strands a pending call and deadlocks the model; the refusal creates no response of its own. A burst of typed commands coalesces into one response while keeping both conversation items.
+  - **A typed command supersedes the turn it interrupts** (2026-08-21; hardened 2026-10-17). `sendTextCommand` defers its `response.create` behind an active response instead of colliding with it, marks that response superseded so a late function call from it is refused rather than dispatched, and drops the old turn's queued follow-up. A refused call is still ANSWERED — a terminal `{ok:false, superseded:true}` `function_call_output` — because an unanswered `function_call` strands a pending call and deadlocks the model; the refusal creates no response of its own. A burst of typed commands coalesces into one response while keeping both conversation items. If the local channel rejects the user item, that command requests no response and adds no deferred answer; earlier accepted deferred input remains queued. Interruption and pointer preparation still happen before the send attempt.
   - **Subject reconciliation across satellite catalog rebuilds** (2026-08-21). A dense↔core toggle or TLE refresh clears and repopulates the catalog, so the published subject is re-resolved against the new satrec; a subject that did NOT survive releases the slot. The per-frame refresh cannot do this itself — `_getTrackedFramePosition` returns early once the satellite has no catalog entry — so the reconcile runs at rebuild completion. An empty catalog is a rebuild in flight, not a disappearance.
   - **One aircraft-proximity snapshot** (2026-08-22; hardened 2026-09-30). `collectAircraftProximityWindow` (`src/data/militaryAwareness.js`) computes the Contacts panel cohort once. The voice analyst reads the exact retained snapshot and evaluation timestamp instead of re-scanning live layers, so the panel readout and spoken count for one centre cannot cross snapshots. **Invariant: do not re-derive a proximity count anywhere else.** Each layer retains 20,000 rows and samples one row beyond the cap; a saturated cohort reports `complete:false`, `truncated:true`, and is spoken as a lower bound. They diverged before because the panel read live billboard positions while the analyst used last-fix coordinates over a 2,000-record slice — 111 on screen, 15 spoken. Explicit regions, arbitrary points, and a radius different from the panel radius deliberately keep the general record engine. Entity-centred results carry `window: {engine:'contacts-window', centeredOn, radiusKm, flights, military, aircraft, complete, evaluatedAt}`.
   - **Centre precedence for nearby asks**: explicit place in the question > Contacts subject (a selected non-contact entity never silently becomes the centre) > an entity the user names > the current view, said aloud. Contacts active with no subject uses the view rather than reading an empty panel.

package.json

@@ -277,6 +277,7 @@
     "./tools/mcp": "./src/tools/mcp/index.js",
     "./tools/panel": "./src/tools/panel.js",
     "./tools/services": "./src/tools/services.js",
-    "./view": "./src/view/index.js"
+    "./view": "./src/view/index.js",
+    "./agent/world-packet": "./src/agent/worldPacket.js"
   }
 }

scripts/format-scope.json

@@ -557,6 +557,8 @@
   "src/data/cctvNswSource.test.mjs",
   "src/data/cctvTxdotSource.test.mjs",
   "src/layers/cctv/source.test.mjs",
+  "src/layers/cctv/frames.test.mjs",
+  "src/layers/cctv/rendering.test.mjs",
   "src/data/alprCameras.js",
   "src/data/alprCameras.test.mjs",
   "src/data/dataCredits.test.mjs",
@@ -637,6 +639,7 @@
   "src/voice/control.js",
   "src/voice/realtimeBackend.js",
   "src/voice/realtimeBackend.test.mjs",
+  "src/agent/worldPacket.test.mjs",
   "src/voice/layerSummary.js",
   "build/application-html.js",
   "src/app/sourceSlot.js",
@@ -692,6 +695,7 @@
   "src/ui/shareRestoration.js",
   "src/ui/visualSettings.js",
   "src/ui/panelChrome.js",
+  "src/ui/panelChrome.radioOwnership.test.mjs",
   "src/testSupport/readShellSource.mjs",
   "src/ui/stateOwners.test.mjs",
   "src/layers/flights/records.js",

scripts/package-boundaries.json

@@ -1633,7 +1633,15 @@
       "src/i18n/locale.js",
       "src/i18n/locales/es.json",
       "src/i18n/locales/ru.json",
-      "src/ui/statusText.js"
+      "src/ui/statusText.js",
+      "src/voice/providerCommands.js",
+      "src/voice/providerCapabilities.js",
+      "src/voice/geminiSession.js",
+      "src/voice/geminiAudio.js",
+      "src/voice/geminiCaptureWorklet.js",
+      "src/sources/httpBody.js",
+      "src/sources/requestDeadline.js",
+      "src/i18n/marker.js"
     ],
     "external": []
   },
@@ -2221,6 +2229,7 @@
       "src/voice/commands.js",
       "src/voice/control.js",
       "src/voice/gevActions.js",
+      "src/agent/worldPacket.js",
       "src/voice/speech.js",
       "src/ui/layerNames.js",
       "src/voice/earcon.js",
@@ -2496,7 +2505,12 @@
       "src/layers/airQuality/index.js",
       "src/layers/airQuality/model.js",
       "src/layers/airQuality/source.js",
-      "src/ui/statusText.js"
+      "src/ui/statusText.js",
+      "src/voice/providerCommands.js",
+      "src/voice/providerCapabilities.js",
+      "src/voice/geminiSession.js",
+      "src/voice/geminiAudio.js",
+      "src/voice/geminiCaptureWorklet.js"
     ],
     "external": [
       "hls.js",
@@ -3384,7 +3398,8 @@
       "src/i18n/locale.js",
       "src/i18n/locales/es.json",
       "src/i18n/locales/ru.json",
-      "src/ui/statusText.js"
+      "src/ui/statusText.js",
+      "src/voice/providerCapabilities.js"
     ],
     "external": []
   },
@@ -3951,5 +3966,18 @@
       "src/i18n/marker.js"
     ],
     "external": []
+  },
+  "agent-world-packet": {
+    "exports": ["./agent/world-packet"],
+    "modules": [
+      "src/agent/worldPacket.js",
+      "src/data/layerSnapshot.js",
+      "src/data/feedState.js",
+      "src/contextModePolicy.js",
+      "src/loadingFeedback.js",
+      "src/data/installationFeedback.js",
+      "src/i18n/marker.js"
+    ],
+    "external": ["cesium"]
   }
 }

scripts/precompute-cctv-heights.mjs

@@ -326,8 +326,10 @@ async function main() {
       'src/data/local_data/cctv_ground_heights/cctv_ground_heights.json',
   );
   let sidecar = await loadSidecar(output);
+  // A cold catalog waits for its slowest pack (Tarktee gets 30 s), so allow
+  // more than that.
   const response = await fetch(`${base}/api/cctv/sources`, {
-    signal: AbortSignal.timeout(30_000),
+    signal: AbortSignal.timeout(60_000),
   });
   if (!response.ok) throw new Error(`Catalog HTTP ${response.status}`);
   const catalog = await response.json();

scripts/qa-cctv-v2.mjs

@@ -139,6 +139,56 @@ function record(name, ok, detail) {
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+// Each page.evaluate is bounded by puppeteer's `protocolTimeout` (default
+// 180s). Waits never come close: they poll from Node (below). The headroom is
+// for the few long evaluates, such as enabling the full ~3,700-camera catalog
+// on a real GPU, and matches the other qa-*.mjs harnesses.
+const PROTOCOL_TIMEOUT_MS = 300_000;
+
+/**
+ * Polls an in-page predicate from Node, one short page.evaluate per tick,
+ * until it holds or the budget runs out. Used instead of page.waitForFunction
+ * for two reasons: its default rAF polling stops in a minimised or hidden
+ * headful window (timers keep running, rAF does not), and its result is one
+ * CDP call that protocolTimeout cuts off, while the headful drain budget
+ * reaches ~50 minutes. A predicate that throws fails the run instead of
+ * silently spending the budget.
+ * @param {import('puppeteer').Page} page
+ * @param {Function} predicate - In-page predicate.
+ * @param {object} opts
+ * @param {number} opts.timeoutMs - Overall budget.
+ * @param {number} [opts.intervalMs=250] - Delay between checks.
+ * @param {unknown[]} [opts.args=[]] - Arguments passed to the predicate.
+ *   The predicate must return a boolean: its result crosses CDP by value.
+ * @returns {Promise<boolean>} True if the predicate held within the budget.
+ */
+async function waitForPredicate(
+  page,
+  predicate,
+  { timeoutMs, intervalMs = 250, args = [] },
+) {
+  // performance.now() is monotonic and doesn't advance while the machine
+  // sleeps, so neither a clock change nor a laptop sleep eats the budget.
+  const deadline = performance.now() + timeoutMs;
+  for (;;) {
+    try {
+      if (await page.evaluate(predicate, ...args)) return true;
+    } catch (err) {
+      // A navigation or Vite reload replaces the execution context: poll again.
+      if (
+        !/Execution context was destroyed|Cannot find context/.test(
+          err?.message ?? '',
+        )
+      ) {
+        throw err;
+      }
+    }
+    const remaining = deadline - performance.now();
+    if (remaining <= 0) return false;
+    await sleep(Math.min(intervalMs, remaining));
+  }
+}
+
 // SwiftShader can spend tens of seconds servicing the hover drillPick emitted
 // by page.mouse.move(), before the LEFT_DOWN under test even runs. Position the
 // pointer while ADJUST is disabled, then re-enable it and explicitly render a
@@ -155,29 +205,58 @@ async function positionPointerForGizmoDrag(page, point, frameCount = 3) {
     gev.dataManager.layers
       .get('cctv')
       .module.setParams({ calibrationMode: true });
-    const scene = gev.viewer.scene;
-    let rendered = 0;
-    return new Promise((resolve) => {
-      let settled = false;
-      const finish = (complete) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        remove();
-        resolve(complete);
-      };
-      const remove = scene.postRender.addEventListener(() => {
-        rendered += 1;
-        if (rendered >= count) {
-          finish(true);
-          return;
-        }
+    return (await window.__qaRenderFrames(count, 5000)) >= count;
+  }, frameCount);
+}
+
+/**
+ * Saves a screenshot for human review. These are never a gate, so a capture
+ * that fails (for example when the renderer stalls in a hidden headful window)
+ * is logged instead of ending the run.
+ * @param {import('puppeteer').Page} page
+ * @param {string} file
+ * @param {string} label
+ */
+async function saveReviewShot(page, file, label) {
+  try {
+    await page.screenshot({ path: file });
+    console.log(`  screenshot (${label}) → ${path.relative(REPO_ROOT, file)}`);
+  } catch (err) {
+    console.warn(
+      `  screenshot skipped (${label}): ${path.relative(REPO_ROOT, file)}: ${err?.message ?? err}`,
+    );
+  }
+}
+
+/**
+ * Installs window.__qaRenderFrames(count, capMs) in the page: requests renders
+ * until `count` frames have passed scene.postRender or capMs runs out, and
+ * resolves with the number of frames rendered. The cap keeps a stalled
+ * renderer (headful window asleep or hidden) from hanging the CDP call.
+ * @param {import('puppeteer').Page} page
+ */
+function installRenderFramesHelper(page) {
+  return page.evaluate(() => {
+    window.__qaRenderFrames = (count, capMs) =>
+      new Promise((resolve) => {
+        const scene = window.__godsEyeView.viewer.scene;
+        let frames = 0;
+        const finish = () => {
+          clearTimeout(timer);
+          remove();
+          resolve(frames);
+        };
+        const remove = scene.postRender.addEventListener(() => {
+          if (++frames >= count) {
+            finish();
+            return;
+          }
+          scene.requestRender();
+        });
+        const timer = setTimeout(finish, capMs);
         scene.requestRender();
       });
-      const timer = setTimeout(() => finish(false), 5000);
-      scene.requestRender();
-    });
-  }, frameCount);
+  });
 }
 
 // In-page helper (stringified and re-defined inside each evaluate that needs
@@ -280,23 +359,21 @@ const BEARING_SHIFT_SRC = `
  * @returns {Promise<boolean>} True if tilesLoaded was observed within the timeout.
  */
 function waitForTilesLoaded(page, timeoutMs = 15000) {
-  return page
-    .waitForFunction(
-      () => {
-        const scene = window.__godsEyeView.viewer.scene;
-        const prims = scene.primitives;
-        for (let i = 0; i < prims.length; i++) {
-          const p = prims.get(i);
-          if (p && p.constructor && p.constructor.name === 'Cesium3DTileset') {
-            return p.tilesLoaded === true;
-          }
+  return waitForPredicate(
+    page,
+    () => {
+      const scene = window.__godsEyeView.viewer.scene;
+      const prims = scene.primitives;
+      for (let i = 0; i < prims.length; i++) {
+        const p = prims.get(i);
+        if (p && p.constructor && p.constructor.name === 'Cesium3DTileset') {
+          return p.tilesLoaded === true;
         }
-        return true; // no tileset in the scene — nothing to wait for
-      },
-      { timeout: timeoutMs },
-    )
-    .then(() => true)
-    .catch(() => false);
+      }
+      return true; // no tileset in the scene — nothing to wait for
+    },
+    { timeoutMs },
+  );
 }
 
 /**
@@ -364,6 +441,10 @@ async function main() {
   const chromeExecutable = findChromeExecutable();
   const browser = await puppeteer.launch({
     headless: HEADFUL ? false : 'new',
+    protocolTimeout: PROTOCOL_TIMEOUT_MS,
+    // Talk CDP over a pipe, so no debugging port stays open on localhost for
+    // the length of a headful run.
+    pipe: true,
     ...(chromeExecutable ? { executablePath: chromeExecutable } : {}),
     args: [
       '--no-sandbox',
@@ -397,13 +478,18 @@ async function main() {
     });
     console.log('Loading app...');
     await page.goto(APP_URL, { waitUntil: 'domcontentloaded', timeout: 60000 });
-    await page.waitForFunction(
+    const appReady = await waitForPredicate(
+      page,
       () =>
-        window.__godsEyeView &&
-        window.__godsEyeView.viewer &&
-        window.__godsEyeView.dataManager,
-      { timeout: 60000 },
+        Boolean(
+          window.__godsEyeView &&
+          window.__godsEyeView.viewer &&
+          window.__godsEyeView.dataManager,
+        ),
+      { timeoutMs: 60000 },
     );
+    if (!appReady) throw new Error('app did not initialise within 60s');
+    await installRenderFramesHelper(page);
     // Let the initial fly-to Austin and first tiles settle.
     await sleep(4000);
 
@@ -475,18 +561,15 @@ async function main() {
     console.log(
       `Waiting for geometry-load queue to drain (N=${camCount}, budget ${Math.round(drainBudgetMs / 1000)}s)...`,
     );
-    const drained = await page
-      .waitForFunction(
-        () => {
-          const mod =
-            window.__godsEyeView.dataManager.layers.get('cctv').module;
-          const ui = mod.getUIState();
-          return ui.loading && ui.loading.active === false;
-        },
-        { timeout: drainBudgetMs },
-      )
-      .then(() => true)
-      .catch(() => false);
+    const drained = await waitForPredicate(
+      page,
+      () => {
+        const mod = window.__godsEyeView.dataManager.layers.get('cctv').module;
+        const ui = mod.getUIState();
+        return Boolean(ui.loading) && ui.loading.active === false;
+      },
+      { timeoutMs: drainBudgetMs, intervalMs: 1000 },
+    );
     record(
       `geometry-load queue drains within ${Math.round(drainBudgetMs / 1000)}s (N=${camCount})`,
       drained ? true : HEADFUL ? false : null,
@@ -579,14 +662,11 @@ async function main() {
     const tilesSeenLoaded = await waitForTilesLoaded(page, 45000);
     let sampleFloorOk = false;
     if (tilesSeenLoaded) {
-      sampleFloorOk = await page
-        .waitForFunction(
-          (base) => window.__qaCounters.sampleHeight - base >= 1,
-          { timeout: 30000 },
-          c0.sampleHeight,
-        )
-        .then(() => true)
-        .catch(() => false);
+      sampleFloorOk = await waitForPredicate(
+        page,
+        (base) => window.__qaCounters.sampleHeight - base >= 1,
+        { timeoutMs: 30000, args: [c0.sampleHeight] },
+      );
     }
     const cFloor = await readCounters();
     record(
@@ -1358,18 +1438,7 @@ async function main() {
         },
       });
       window.__qaCctvSiblingOwner = owner;
-      await new Promise((resolve) => {
-        let frames = 0;
-        const remove = scene.postRender.addEventListener(() => {
-          if (++frames < 3) {
-            scene.requestRender();
-            return;
-          }
-          remove();
-          resolve();
-        });
-        scene.requestRender();
-      });
+      const framesRendered = await window.__qaRenderFrames(3, 10000);
       const rect = scene.canvas.getBoundingClientRect();
       const picked = scene.pick(canvasPoint);
       const pickedId = picked?.id?.id ?? picked?.id ?? null;
@@ -1382,26 +1451,33 @@ async function main() {
           typeof pickedId === 'string' ? pickedId : (pickedId?.id ?? null),
         ownerId: owner.id,
         ownsExactObject: picked?.id === owner,
+        framesRendered,
         projectionDelta: Math.hypot(
           projected.x - canvasPoint.x,
           projected.y - canvasPoint.y,
         ),
       };
     }, emptyClickPoint);
+    const siblingOwnsPick =
+      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
+      siblingTarget.ownsExactObject;
+    // No frame at all within the 10s cap points at a stalled renderer rather
+    // than at picking, though the harness can't rule out both. Fail it on the
+    // real-GPU sign-off path; leave it inconclusive under headless GL. A slow
+    // SwiftShader frame (1-2 of 3) still counts as a real miss.
+    const siblingRendererStalled =
+      siblingTarget && !siblingOwnsPick && siblingTarget.framesRendered === 0;
     record(
       'sibling test object owns its canvas pick',
+      !siblingTarget
+        ? null
+        : siblingOwnsPick ||
+            (siblingRendererStalled && !HEADFUL ? null : false),
       siblingTarget
-        ? siblingTarget.pickedId === 'qa-cctv-sibling-owner' &&
-            siblingTarget.ownsExactObject
-        : null,
-      siblingTarget
-        ? `picked=${siblingTarget.pickedId} exactOwner=${siblingTarget.ownsExactObject} projectionΔ=${siblingTarget.projectionDelta}`
+        ? `${siblingRendererStalled ? 'renderer stalled: ' : ''}frames=${siblingTarget.framesRendered}/3 picked=${siblingTarget.pickedId} exactOwner=${siblingTarget.ownsExactObject} projectionΔ=${siblingTarget.projectionDelta}`
         : 'no previously verified empty canvas ray was available',
     );
-    if (
-      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
-      siblingTarget.ownsExactObject
-    ) {
+    if (siblingOwnsPick) {
       await page.mouse.click(siblingTarget.x, siblingTarget.y);
       await sleep(250);
     }
@@ -1426,8 +1502,7 @@ async function main() {
     });
     record(
       'sibling canvas click passes through without CCTV selection or deselection',
-      siblingTarget?.pickedId === 'qa-cctv-sibling-owner' &&
-        siblingTarget.ownsExactObject
+      siblingOwnsPick
         ? siblingClick.activeId === clickEvidenceSetup.activeId &&
             siblingClick.transitions === siblingClick.baselineTransitions &&
             siblingClick.focusEvents === 0 &&
@@ -1626,10 +1701,7 @@ async function main() {
     );
 
     const viewshedShot = path.join(SHOTS_DIR, 'cctv-v3-viewshed.png');
-    await page.screenshot({ path: viewshedShot });
-    console.log(
-      `  screenshot (visual review only) → ${path.relative(REPO_ROOT, viewshedShot)}`,
-    );
+    await saveReviewShot(page, viewshedShot, 'visual review only');
 
     // =========================================================================
     // Group 7: calibration gizmo (v3 design §3c — ADJUST mode + drag)
@@ -1963,10 +2035,7 @@ async function main() {
     // -----------------------------------------------------------------------
     await sleep(1000);
     const shot = path.join(SHOTS_DIR, 'cctv-v2-active.png');
-    await page.screenshot({ path: shot });
-    console.log(
-      `  screenshot (visual review only, not a gate) → ${path.relative(REPO_ROOT, shot)}`,
-    );
+    await saveReviewShot(page, shot, 'visual review only, not a gate');
 
     // No console errors during the whole exercise.
     record(

scripts/qa-panel-resize.mjs

@@ -298,11 +298,12 @@ async function main() {
     );
     console.log('PASS: header drag lifts CCTV out of the rail');
 
-    // Park near the top: the voice dock would cover the south corners once
-    // the loop below has grown the window.
+    // Park above and right of the voice dock and its raised provider chooser:
+    // growing every edge must leave the south handles clear of both controls.
     {
+      const panel = await readPanel();
       const header = await headerPoint();
-      await drag(header, 0, 120 - header.y);
+      await drag(header, 900 - panel.left, 120 - header.y);
     }
 
     const limits = {

server/providers/cctv.js

@@ -143,7 +143,7 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) {
 
         if (url.pathname === '/sources') {
           const body = {
-            trimmedPacks: getCctvSources.trimmedPacks?.() ?? [],
+            trimmedPacks: getCctvSources.trimmedPacks?.(sources) ?? [],
             sources: sources.map((source) => ({
               id: source.id,
               pack: source.pack,

server/providers/cctv/catalog.js

@@ -204,16 +204,19 @@ export function createCctvCatalog({ sourceRoot = process.cwd() } = {}) {
   /** @type {Promise<Array<object>>|null} In-flight refresh, shared by concurrent
    * callers so a post-TTL burst launches ONE refetch, not one per request. */
   let _cctvSourceInflight = null;
-  /** @type {Array<{pack: string, available: number, served: number}>} Packs
-   * that serve fewer cameras than they offer. */
-  let _cctvTrimmedPacks = [];
+  /** @type {WeakMap<Array<object>, Array<{pack: string, available: number, served: number}>>}
+   * Packs that serve fewer cameras than they offer, keyed by the source list
+   * they describe, so a request served the old list during a background
+   * refresh never pairs it with the new list's trim notes. */
+  const _cctvTrimmedPacks = new WeakMap();
 
   /**
    * Assemble and cache the merged CCTV source list.
    *
    * Merges every source pack (live open-data packs, local file, env
    * variable), deduplicates by ID, shares the catalog cap fairly across
-   * packs, and caches for CCTV_SOURCE_CACHE_MS.
+   * packs, and caches for CCTV_SOURCE_CACHE_MS. Past that, the cached list is
+   * returned while a background refresh replaces it; only a first load waits.
    *
    * @returns {Promise<Array<object>>} Deduplicated, capped source list.
    */
@@ -228,11 +231,31 @@ export function createCctvCatalog({ sourceRoot = process.cwd() } = {}) {
     // Single-flight: a burst of requests arriving past the TTL shares ONE refresh
     // instead of each launching the full multi-provider refetch. The `.finally`
     // clears the ref so the next post-TTL cycle starts fresh.
-    if (_cctvSourceInflight) return _cctvSourceInflight;
-    _cctvSourceInflight = refreshCctvSources().finally(() => {
-      _cctvSourceInflight = null;
-    });
-    return _cctvSourceInflight;
+    if (!_cctvSourceInflight) {
+      _cctvSourceInflight = refreshCctvSources().finally(() => {
+        _cctvSourceInflight = null;
+      });
+      // A background refresh has no caller waiting on it: report its failure
+      // here, once per refresh rather than once per request it serves. Keep
+      // the old catalog for another TTL, as an empty refresh does, so a refresh
+      // that keeps failing is retried once per TTL, not back to back.
+      if (_cctvSourceCache.length) {
+        _cctvSourceInflight.catch((error) => {
+          _cctvSourceCacheAt = Date.now();
+          console.warn(
+            '[CCTV] background catalog refresh failed; serving',
+            _cctvSourceCache.length,
+            'cameras from the last catalog:',
+            error?.message || error,
+          );
+        });
+      }
+    }
+    // With a catalog in hand, answer with it while the refresh runs: the
+    // refresh lasts as long as the slowest pack (Tarktee's DATEX feeds take up
+    // to its 30 s timeout), and every /api/cctv request would otherwise wait
+    // for it. Only the first load, with nothing to serve yet, waits.
+    return _cctvSourceCache.length ? _cctvSourceCache : _cctvSourceInflight;
   }
 
   /**
@@ -322,7 +345,7 @@ export function createCctvCatalog({ sourceRoot = process.cwd() } = {}) {
     }
     if (capped.length > 0 || _cctvSourceCache.length === 0) {
       _cctvSourceCache = capped;
-      _cctvTrimmedPacks = trimmedPacks;
+      _cctvTrimmedPacks.set(capped, trimmedPacks);
     } else {
       // Every source came back empty (all live packs timed out / upstream outage)
       // but a good catalog is already cached — serve it stale rather than blanking
@@ -336,7 +359,10 @@ export function createCctvCatalog({ sourceRoot = process.cwd() } = {}) {
     return _cctvSourceCache;
   }
 
-  /** Packs serving fewer cameras than they offer, as of the last refresh. */
-  getCctvSources.trimmedPacks = () => _cctvTrimmedPacks;
+  /** Packs serving fewer cameras than they offer in `sources` (by default the
+   * current catalog). Pass the list a request was served to keep the two in
+   * step while a background refresh swaps the catalog. */
+  getCctvSources.trimmedPacks = (sources = _cctvSourceCache) =>
+    _cctvTrimmedPacks.get(sources) ?? [];
   return getCctvSources;
 }

server/providers/cctv/constants.js

@@ -503,6 +503,10 @@ export const CCTV_SOURCE_CACHE_MS = 15 * 60 * 1000;
  * pending forever — a hung fetch aborts, the loader returns [], and
  * serve-stale/other packs take over. */
 export const CCTV_SOURCE_FETCH_TIMEOUT_MS = 15 * 1000;
+/** Tarktee's two DATEX feeds (120 and 160 KB) answered in 2 to 16.6 s across
+ * ten requests on 2026-10-18, so the shared 15 s timeout dropped the Estonian
+ * pack on about a third of loads. Both must arrive for any camera to load. */
+export const TARKTEE_FETCH_TIMEOUT_MS = 30 * 1000;
 /** Individual CCTV image fetches must settle before the active 10-second
  * client refresh cadence. A bounded miss can fall through to Street View or
  * the synthetic frame instead of leaving the browser preview pending. */

server/providers/cctv/sources.js

@@ -76,6 +76,7 @@ import {
   TORONTO_GROUND_ELEVATION_M,
   TORONTO_MAX_CATALOG_BYTES,
   CCTV_SOURCE_FETCH_TIMEOUT_MS,
+  TARKTEE_FETCH_TIMEOUT_MS,
   DELDOT_CCTV_URL,
   DEFAULT_DELDOT_MAX_SOURCES,
   DELDOT_ANCHORS,
@@ -1214,11 +1215,11 @@ export async function loadTarkteeSourcesFromDatex() {
     const [locResp, imgResp] = await Promise.all([
       fetch(TARKTEE_LOCATIONS_URL, {
         headers: { Accept: 'application/xml,text/xml,*/*' },
-        signal: AbortSignal.timeout(CCTV_SOURCE_FETCH_TIMEOUT_MS),
+        signal: AbortSignal.timeout(TARKTEE_FETCH_TIMEOUT_MS),
       }),
       fetch(TARKTEE_IMAGES_URL, {
         headers: { Accept: 'application/xml,text/xml,*/*' },
-        signal: AbortSignal.timeout(CCTV_SOURCE_FETCH_TIMEOUT_MS),
+        signal: AbortSignal.timeout(TARKTEE_FETCH_TIMEOUT_MS),
       }),
     ]);
     if (!locResp.ok) {

server/providers/common/request.js

@@ -14,16 +14,34 @@ async function readRequestBodyCapped(req, maxBytes) {
   return Buffer.concat(chunks);
 }
 
-function readRequestBody(req, maxBytes = 1024 * 1024) {
+/** Optional cancellation discards buffered data while the request drains. */
+function readRequestBody(req, maxBytes = 1024 * 1024, signal) {
   return new Promise((resolve, reject) => {
     let total = 0;
     let bodyTooLarge = false;
+    let settled = false;
     const chunks = [];
-    req.on('data', (chunk) => {
+    const stopReading = () => {
+      if (!signal) return;
+      req.off('data', data);
+      req.off('end', end);
+      signal.removeEventListener('abort', abort);
+    };
+    const fail = (error) => {
+      if (signal) {
+        if (settled) return;
+        settled = true;
+        chunks.length = 0;
+        signal.removeEventListener('abort', abort);
+      }
+      reject(error);
+    };
+    const abort = () => fail(signal.reason);
+    const data = (chunk) => {
       // Keep draining after the cap without retaining more bytes. Destroying
       // the request also destroys its socket, so the handler cannot deliver
       // the fixed error response it constructs for BODY_TOO_LARGE.
-      if (bodyTooLarge) return;
+      if (bodyTooLarge || settled) return;
       total += chunk.length;
       if (total > maxBytes) {
         // Same marker readRequestBodyCapped sets, so a caller can tell an
@@ -32,15 +50,42 @@ function readRequestBody(req, maxBytes = 1024 * 1024) {
         chunks.length = 0;
         const error = new Error(`Request body exceeds ${maxBytes} bytes`);
         error.code = 'BODY_TOO_LARGE';
-        reject(error);
+        fail(error);
         return;
       }
       chunks.push(chunk);
-    });
-    req.on('end', () => {
+    };
+    const end = () => {
+      if (settled) {
+        stopReading();
+        return;
+      }
       if (!bodyTooLarge) resolve(Buffer.concat(chunks).toString('utf8'));
-    });
-    req.on('error', reject);
+      if (signal) {
+        settled = true;
+        chunks.length = 0;
+        stopReading();
+      }
+    };
+    const close = () => {
+      fail(
+        new DOMException('Request closed before its body ended', 'AbortError'),
+      );
+      stopReading();
+      req.off('error', fail);
+      req.off('close', close);
+    };
+    if (signal) {
+      // Abort/overflow release retained bytes but keep draining. Retain an
+      // error handler until close, including a late error after end/abort.
+      req.on('close', close);
+      signal.addEventListener('abort', abort, { once: true });
+      if (signal.aborted) abort();
+    }
+    req.on('data', data);
+    req.on('end', end);
+    req.on('error', fail);
+    if (signal && req.destroyed) close();
   });
 }
 

server/providers/common/request.test.mjs

@@ -0,0 +1,137 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter, getEventListeners } from 'node:events';
+import { readRequestBody } from './request.js';
+
+function fixture() {
+  const req = new EventEmitter();
+  req.pause = () => assert.fail('The reader must keep draining');
+  req.destroy = () =>
+    assert.fail('The reader must preserve the response socket');
+  const owner = new AbortController();
+  return { req, owner };
+}
+
+function finish(req, owner) {
+  assert.doesNotThrow(() => req.emit('error', new Error('late stream error')));
+  req.emit('end');
+  assert.doesNotThrow(() => req.emit('error', new Error('error before close')));
+  req.emit('close');
+  for (const event of ['data', 'end', 'error', 'close'])
+    assert.equal(req.listenerCount(event), 0, event);
+  assert.equal(getEventListeners(owner.signal, 'abort').length, 0);
+}
+
+test('default and cancellable readers preserve byte caps and UTF-8 across chunks', async () => {
+  for (const useSignal of [false, true]) {
+    for (const text of ['', 'hello', 'é']) {
+      const { req, owner } = fixture();
+      const bytes = Buffer.from(text);
+      const body = readRequestBody(
+        req,
+        bytes.length,
+        useSignal ? owner.signal : undefined,
+      );
+      for (const byte of bytes) req.emit('data', Buffer.from([byte]));
+      req.emit('end');
+      assert.equal(await body, text);
+      if (useSignal) finish(req, owner);
+    }
+  }
+});
+
+test('default overflow rejects before end and drains without pausing or destroying', async () => {
+  const { req } = fixture();
+  const rejection = assert.rejects(readRequestBody(req, 2), {
+    code: 'BODY_TOO_LARGE',
+  });
+  req.emit('data', Buffer.from('é'));
+  req.emit('data', Buffer.from('!'));
+  await rejection;
+  req.emit('data', Buffer.alloc(4096));
+  assert.doesNotThrow(() => req.emit('error', new Error('late')));
+  req.emit('end');
+});
+
+test('partial abort settles before end, discards late data and guards errors until close', async () => {
+  const { req, owner } = fixture();
+  const reason = new Error('request deadline');
+  const rejection = assert.rejects(
+    readRequestBody(req, 1024, owner.signal),
+    (error) => error === reason,
+  );
+  req.emit('data', Buffer.from('partial'));
+  owner.abort(reason);
+  await rejection;
+  assert.equal(getEventListeners(owner.signal, 'abort').length, 0);
+  req.emit('data', Buffer.alloc(4096));
+  finish(req, owner);
+});
+
+test('already-aborted and already-closed requests settle and release their listeners', async () => {
+  for (const closed of [false, true]) {
+    const { req, owner } = fixture();
+    if (closed) req.destroyed = true;
+    else owner.abort();
+    await assert.rejects(readRequestBody(req, 1024, owner.signal), {
+      name: 'AbortError',
+    });
+    if (!closed) finish(req, owner);
+    for (const event of ['data', 'end', 'error', 'close'])
+      assert.equal(req.listenerCount(event), 0);
+    assert.equal(getEventListeners(owner.signal, 'abort').length, 0);
+  }
+});
+
+test('overflow keeps its first failure through later abort and stream errors', async () => {
+  const { req, owner } = fixture();
+  const rejection = assert.rejects(readRequestBody(req, 2, owner.signal), {
+    code: 'BODY_TOO_LARGE',
+  });
+  req.emit('data', Buffer.from('é!'));
+  await rejection;
+  owner.abort(new Error('later deadline'));
+  req.emit('data', Buffer.alloc(4096));
+  finish(req, owner);
+});
+
+test('early close and request error reject once; successful end wins over later abort', async () => {
+  for (const event of ['close', 'error', 'end']) {
+    const { req, owner } = fixture();
+    const reason = new Error('request failed');
+    const body = readRequestBody(req, 32, owner.signal);
+    const observed =
+      event === 'end'
+        ? body.then((value) => assert.equal(value, 'ok'))
+        : assert.rejects(
+            body,
+            event === 'close'
+              ? { name: 'AbortError' }
+              : (error) => error === reason,
+          );
+    req.emit('data', Buffer.from('ok'));
+    req.emit(event, reason);
+    owner.abort(new Error('later abort'));
+    await observed;
+    if (event !== 'close') finish(req, owner);
+    assert.equal(getEventListeners(owner.signal, 'abort').length, 0);
+  }
+});
+
+test('a prior data observer can abort synchronously without retaining or resolving that chunk', async () => {
+  const { req, owner } = fixture();
+  const reason = new Error('observer stopped request');
+  const external = () => owner.abort(reason);
+  req.on('data', external);
+  const rejection = assert.rejects(
+    readRequestBody(req, 1024, owner.signal),
+    (error) => error === reason,
+  );
+  req.emit('data', Buffer.from('must be discarded'));
+  await rejection;
+  req.emit('end');
+  req.emit('close');
+  assert.deepEqual(req.listeners('data'), [external]);
+  assert.equal(getEventListeners(owner.signal, 'abort').length, 0);
+  req.off('data', external);
+});

server/providers/gemini.js

@@ -0,0 +1,22 @@
+import { createGeminiTokenHandler } from './gemini/realtime.js';
+
+/** Mint constrained Live API credentials; the permanent key stays on Node. */
+function geminiLiveProxy({ annotationGuidance, realtime = {} } = {}) {
+  function install(middlewares) {
+    middlewares.use(
+      '/api/gemini/token',
+      createGeminiTokenHandler({ ...realtime, annotationGuidance }),
+    );
+  }
+  return {
+    name: 'gemini-live-proxy',
+    configureServer(server) {
+      install(server.middlewares);
+    },
+    configurePreviewServer(server) {
+      install(server.middlewares);
+    },
+  };
+}
+
+export { geminiLiveProxy };

server/providers/gemini/config.js

@@ -0,0 +1,53 @@
+import { realtimeInstructions } from '../openai/instructions.js';
+import { GEV_REALTIME_TOOLS } from '../openai/tools.js';
+
+export const GEMINI_LIVE_MODEL_DEFAULT = 'gemini-3.8-live';
+export const GEMINI_TOKEN_ENDPOINT =
+  'https://generativelanguage.googleapis.com/v1beta/auth_tokens';
+export const GEMINI_LIVE_WEBSOCKET_URL =
+  'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContentConstrained';
+
+export function normalizeGeminiModel(value) {
+  const model = String(value ?? GEMINI_LIVE_MODEL_DEFAULT)
+    .trim()
+    .replace(/^models\//, '');
+  return /^gemini-[a-z0-9][a-z0-9.-]{0,119}$/.test(model) ? model : null;
+}
+
+/** REST BidiGenerateContentSetup fields, excluding its model resource name. */
+export function createGeminiLiveConfig(
+  annotationGuidance,
+  inputMode = 'open-mic',
+  tools = GEV_REALTIME_TOOLS,
+) {
+  if (!['open-mic', 'push-to-talk'].includes(inputMode))
+    throw new Error('Invalid Gemini input mode');
+  const config = {
+    generationConfig: { responseModalities: ['AUDIO'] },
+    systemInstruction: {
+      parts: [{ text: realtimeInstructions(annotationGuidance) }],
+    },
+    tools: [
+      {
+        functionDeclarations: tools.map(
+          ({ name, description, parameters }) => ({
+            name,
+            description,
+            // GEV's canonical schemas are JSON Schema, not Google's Schema.
+            parametersJsonSchema: structuredClone(parameters),
+            // App actions must finish before the model confirms their result.
+            behavior: 'BLOCKING',
+          }),
+        ),
+      },
+    ],
+    inputAudioTranscription: {},
+    outputAudioTranscription: {},
+    contextWindowCompression: { slidingWindow: {} },
+  };
+  if (inputMode === 'push-to-talk')
+    config.realtimeInputConfig = {
+      automaticActivityDetection: { disabled: true },
+    };
+  return config;
+}

server/providers/gemini/realtime.js

@@ -0,0 +1,208 @@
+import { waitForSignal } from '../../../src/sources/requestDeadline.js';
+import { clientKey, makeCostRateLimiter } from '../common/rate-limit.js';
+import { readResponseJsonCapped } from '../../../src/sources/httpBody.js';
+import {
+  GEMINI_TOKEN_ENDPOINT,
+  GEMINI_LIVE_WEBSOCKET_URL,
+  GEMINI_LIVE_MODEL_DEFAULT,
+  createGeminiLiveConfig,
+  normalizeGeminiModel,
+} from './config.js';
+import {
+  isGeminiRequestOriginAllowed,
+  readGeminiTokenRequest,
+} from './request.js';
+
+const UPSTREAM_RESPONSE_BYTES = 32 * 1024;
+const MINT_FAILURE = 'Gemini voice could not connect. Try again.';
+
+export function createGeminiTokenHandler({
+  annotationGuidance,
+  tools,
+  fetchImpl = (...args) => fetch(...args),
+  resolveApiKey = () => process.env.GEMINI_API_KEY,
+  resolveModel = () =>
+    process.env.GEMINI_LIVE_MODEL || GEMINI_LIVE_MODEL_DEFAULT,
+  resolveHost = () => process.env.HOST,
+  resolveAllowedHosts = () => process.env.GEV_ALLOWED_HOSTS,
+  resolveRateLimit = () => process.env.GEV_RATELIMIT_GEMINI_PER_MIN ?? '30',
+  now = Date.now,
+  timeoutMs = 15_000,
+} = {}) {
+  let limiter;
+  return async (req, res) => {
+    if (req.aborted || res.destroyed || res.writableEnded) return;
+    res.setHeader('Cache-Control', 'no-store');
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    const reply = (status, errorOrPayload) => {
+      if (res.destroyed || res.writableEnded) return;
+      res.statusCode = status;
+      if (status >= 400) res.setHeader('Connection', 'close');
+      res.end(
+        JSON.stringify(
+          typeof errorOrPayload === 'string'
+            ? { error: errorOrPayload }
+            : errorOrPayload,
+        ),
+      );
+    };
+    if (req.method !== 'POST') {
+      res.setHeader('Allow', 'POST');
+      return reply(405, 'Method not allowed');
+    }
+    let apiKey;
+    let model;
+    try {
+      if (
+        !isGeminiRequestOriginAllowed(req, resolveHost(), resolveAllowedHosts())
+      )
+        return reply(403, 'Gemini voice requires a same-origin app request');
+      apiKey = String(resolveApiKey() || '').trim();
+      if (!apiKey)
+        return reply(503, 'Add a Gemini API key in Provider Settings');
+      model = normalizeGeminiModel(resolveModel());
+      if (!model)
+        return reply(503, 'The Gemini Live model configuration is invalid');
+      if (limiter === undefined)
+        limiter = makeCostRateLimiter(resolveRateLimit(), 30);
+      if (limiter && !limiter(clientKey(req))) {
+        res.setHeader('Retry-After', '60');
+        return reply(
+          429,
+          'Gemini voice is starting too often. Try again shortly.',
+        );
+      }
+    } catch {
+      // Connect does not observe the handler's returned promise. A synchronous
+      // configuration resolver must fail with a bounded, fixed response.
+      return reply(503, MINT_FAILURE);
+    }
+
+    const lifetime = new AbortController();
+    let disconnected = false;
+    const disconnect = () => {
+      disconnected = true;
+      lifetime.abort(new DOMException('Request closed', 'AbortError'));
+    };
+    const responseClosed = () => {
+      if (!res.writableEnded) disconnect();
+    };
+    req.once('aborted', disconnect);
+    res.once('close', responseClosed);
+    const deadline = setTimeout(() => {
+      lifetime.abort(
+        new DOMException('Token request timed out', 'TimeoutError'),
+      );
+    }, timeoutMs);
+    deadline.unref?.();
+    let acquiredResponse;
+    try {
+      const inputMode = await readGeminiTokenRequest(req, lifetime.signal);
+      lifetime.signal.throwIfAborted();
+      const config = createGeminiLiveConfig(
+        annotationGuidance,
+        inputMode,
+        tools,
+      );
+      const issuedAt = now();
+      // REST uses bidiGenerateContentSetup. liveConnectConstraints is the SDK
+      // input shape, converted before transport. With no fieldMask the complete
+      // setup is locked to this server-owned configuration.
+      const request = {
+        uses: 1,
+        expireTime: new Date(issuedAt + 30 * 60_000).toISOString(),
+        newSessionExpireTime: new Date(issuedAt + 60_000).toISOString(),
+        bidiGenerateContentSetup: { model: `models/${model}`, ...config },
+      };
+      const acquisition = Promise.resolve(
+        fetchImpl(GEMINI_TOKEN_ENDPOINT, {
+          method: 'POST',
+          redirect: 'error',
+          signal: lifetime.signal,
+          headers: {
+            'x-goog-api-key': apiKey,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(request),
+        }),
+      );
+      // A fetch implementation can ignore abort. Bound this caller's wait and
+      // discard a response that arrives after timeout/disconnection.
+      void acquisition.then(
+        (late) => {
+          acquiredResponse = late;
+          if (lifetime.signal.aborted) void late.body?.cancel().catch(() => {});
+        },
+        () => {},
+      );
+      const response = await waitForSignal(acquisition, lifetime.signal);
+      lifetime.signal.throwIfAborted();
+      if (
+        response.redirected ||
+        (response.url && response.url !== GEMINI_TOKEN_ENDPOINT)
+      ) {
+        void response.body?.cancel().catch(() => {});
+        throw new Error('Unexpected token response destination');
+      }
+      if (!response.ok) {
+        // Never forward upstream bodies, headers or exception messages.
+        void response.body?.cancel().catch(() => {});
+        if (response.status === 429) {
+          res.setHeader('Retry-After', '60');
+          return reply(429, 'Gemini quota is unavailable. Try again later.');
+        }
+        if (response.status === 401 || response.status === 403)
+          return reply(
+            503,
+            'Gemini access was refused. Check the API key and model access.',
+          );
+        if (response.status === 400 || response.status === 404)
+          return reply(
+            502,
+            'Gemini Live is unavailable for the configured model.',
+          );
+        return reply(502, MINT_FAILURE);
+      }
+      const data = await readResponseJsonCapped(
+        response,
+        UPSTREAM_RESPONSE_BYTES,
+        lifetime.signal,
+      );
+      lifetime.signal.throwIfAborted();
+      if (
+        !data ||
+        Array.isArray(data) ||
+        typeof data !== 'object' ||
+        typeof data.name !== 'string' ||
+        data.name.length > 8192 ||
+        !/^auth_tokens\/[A-Za-z0-9._~+/=-]+$/.test(data.name) ||
+        data.name.includes(apiKey)
+      )
+        throw new Error('Invalid ephemeral token');
+      reply(200, {
+        token: data.name,
+        model,
+        config,
+        websocketUrl: GEMINI_LIVE_WEBSOCKET_URL,
+      });
+    } catch (error) {
+      if (disconnected || req.aborted) return;
+      if (error?.code === 'BODY_TOO_LARGE')
+        return reply(413, 'Token request is too large');
+      if (error?.code === 'BAD_CONTENT_TYPE')
+        return reply(415, 'Use an empty JSON token request');
+      if (error?.code === 'BAD_BODY')
+        return reply(400, 'Use an empty JSON token request');
+      reply(lifetime.signal.aborted ? 504 : 502, MINT_FAILURE);
+    } finally {
+      // Abort can happen after acquisition resolves but before this handler
+      // resumes and passes ownership to the body reader.
+      if (lifetime.signal.aborted)
+        void acquiredResponse?.body?.cancel().catch(() => {});
+      clearTimeout(deadline);
+      req.off('aborted', disconnect);
+      res.off('close', responseClosed);
+    }
+  };
+}

server/providers/gemini/request.js

@@ -0,0 +1,79 @@
+import { readRequestBody } from '../common/request.js';
+import { admitSameSiteRequest } from '../../../src/localRequestGate.mjs';
+import {
+  isAllowedHost,
+  resolveAllowedHosts,
+} from '../../../build/allowedHosts.js';
+
+/** Use the app's Host and request policies, with a required browser Origin. */
+export function isGeminiRequestOriginAllowed(
+  req,
+  configuredHost = '',
+  configuredAllowedHosts,
+) {
+  const host = req.headers?.host;
+  const origin = req.headers?.origin;
+  if (
+    typeof host !== 'string' ||
+    typeof origin !== 'string' ||
+    !host ||
+    !origin ||
+    /[\s/?#@\\]/.test(host)
+  )
+    return false;
+  const protocol = req.socket?.encrypted ? 'https:' : 'http:';
+  if (
+    !admitSameSiteRequest({
+      hostHeader: host,
+      protocol,
+      origin,
+      secFetchSite: req.headers?.['sec-fetch-site'],
+      proxyHeaders: req.headers || {},
+    }).ok
+  )
+    return false;
+  // The shared gate compares a present Origin exactly with this authority;
+  // this route also requires the Origin and an allowed Host.
+  const boundHost = String(configuredHost || '')
+    .trim()
+    .toLowerCase();
+  return isAllowedHost(host, resolveAllowedHosts(configuredAllowedHosts), [
+    boundHost,
+  ]);
+}
+
+/** Admit only the existing input gesture; callers cannot supply model/setup. */
+export async function readGeminiTokenRequest(req, signal, maxBytes = 1024) {
+  const declared = Number(req.headers?.['content-length']);
+  const fail = (code) =>
+    Object.assign(new Error('Invalid token request'), { code });
+  const body = await readRequestBody(
+    req,
+    maxBytes,
+    Number.isFinite(declared) && declared > maxBytes
+      ? AbortSignal.abort(fail('BODY_TOO_LARGE'))
+      : signal,
+  );
+  if (!body.trim()) return 'open-mic';
+  if (
+    !/^application\/json(?:\s*;|$)/i.test(req.headers?.['content-type'] || '')
+  )
+    throw fail('BAD_CONTENT_TYPE');
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw fail('BAD_BODY');
+  }
+  if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object')
+    throw fail('BAD_BODY');
+  const keys = Object.keys(parsed);
+  if (!keys.length) return 'open-mic';
+  if (
+    keys.length === 1 &&
+    keys[0] === 'inputMode' &&
+    parsed.inputMode === 'push-to-talk'
+  )
+    return 'push-to-talk';
+  throw fail('BAD_BODY');
+}

server/providers/local.js

@@ -19,6 +19,7 @@ import { adsbLolProxy } from './aircraft/adsb-lol.js';
 import { aisLiveProxy } from './vessels/ais-live.js';
 import { trackBackfillProxies } from './aircraft/tracks.js';
 import { openAiRealtimeProxy } from './openai.js';
+import { geminiLiveProxy } from './gemini.js';
 import { googlePlacesContextProxy } from './places.js';
 import { mapillaryProxy } from './mapillary.js';
 import { keySetupEndpoint } from '../standalone/key-setup.js';
@@ -30,9 +31,9 @@ import { windProxy } from './wind.js';
 
 /**
  * Construct the local provider plugins in their established order.
- * `realtime` configures the voice session token endpoint.
+ * `realtime` configures OpenAI; `gemini` explicitly opts into Gemini Live.
  */
-function localProviderPlugins({ realtime } = {}) {
+function localProviderPlugins({ realtime, gemini } = {}) {
   return [
     openSkyProxy(),
     celestrakProxy(),
@@ -55,6 +56,7 @@ function localProviderPlugins({ realtime } = {}) {
     aisLiveProxy(),
     trackBackfillProxies(),
     openAiRealtimeProxy({ realtime }),
+    ...(gemini ? [geminiLiveProxy({ realtime: gemini })] : []),
     googlePlacesContextProxy(),
     windProxy(),
     weatherProxy(),

server/standalone/vite.config.js

@@ -16,9 +16,10 @@ export default defineConfig(({ command, mode }) => {
   for (const [key, value] of Object.entries(loaded)) {
     if (process.env[key] === undefined) process.env[key] = value;
   }
+  const tools = standaloneVoiceTools();
   return createBrowserViteConfig({
     plugins: [
-      ...localProviderPlugins({ realtime: { tools: standaloneVoiceTools() } }),
+      ...localProviderPlugins({ realtime: { tools }, gemini: { tools } }),
       localMcpPlugin(),
       apiNotFoundPlugin(),
       unwatchedRuntimeDirsPlugin(),

src/agent/worldPacket.js

@@ -0,0 +1,170 @@
+import * as Cesium from 'cesium';
+import {
+  feedProvenanceEnvelope,
+  layerSnapshot,
+  layerSnapshots,
+} from '../data/layerSnapshot.js';
+import { contextModeWord } from '../contextModePolicy.js';
+
+export const TRACKABLE_FAMILIES = Object.freeze([
+  { layerId: 'flights', kind: 'aircraft' },
+  { layerId: 'military', kind: 'aircraft' },
+  { layerId: 'ais-live-vessels', kind: 'vessel' },
+  { layerId: 'satellites', kind: 'satellite' },
+]);
+
+const CONTEXT_MODE_RESULT_FIELDS = Object.freeze([
+  { field: 'mode', emptyAs: 'off' },
+  { field: 'entering', emptyAs: null },
+  { field: 'priorMode', emptyAs: null },
+]);
+
+const NESTED_CONTEXT_RESULT_FIELDS = Object.freeze([
+  'context',
+  'contextRollback',
+]);
+
+/**
+ * Translate context-mode payloads into the public tool vocabulary while
+ * retaining the internal id beside each translated field.
+ */
+export function withContextModeVocabulary(state) {
+  if (!state || typeof state !== 'object') return state;
+  let out = state;
+  const mutable = () => {
+    if (out === state) out = { ...state };
+    return out;
+  };
+  for (const { field, emptyAs } of CONTEXT_MODE_RESULT_FIELDS) {
+    if (!(field in state)) continue;
+    const internal = state[field] ?? null;
+    const target = mutable();
+    target[field] = contextModeWord(internal, { emptyAs });
+    target[`${field}Internal`] = internal;
+  }
+  for (const field of NESTED_CONTEXT_RESULT_FIELDS) {
+    const nested = state[field];
+    if (!nested || typeof nested !== 'object') continue;
+    const translated = withContextModeVocabulary(nested);
+    if (translated !== nested) mutable()[field] = translated;
+  }
+  return out;
+}
+
+/** Read tracked entities from their canonical layer owners. */
+export function collectTrackedEntities(dataManager) {
+  const tracked = [];
+  for (const family of TRACKABLE_FAMILIES) {
+    const module = dataManager?.layers?.get(family.layerId)?.module;
+    if (!module) continue;
+    try {
+      const info =
+        family.kind === 'vessel'
+          ? module.getSelectedInfo?.()
+          : module.getTrackedInfo?.();
+      if (info)
+        tracked.push({
+          kind: family.kind,
+          layerId: family.layerId,
+          ...info,
+        });
+    } catch {
+      // A not-yet-ready layer contributes no tracked observation.
+    }
+  }
+  return tracked;
+}
+
+/** Read the active Contacts window from its owning awareness layer. */
+export function activeContactsWindow(dataManager) {
+  try {
+    const layer = dataManager?.layers?.get('military-awareness')?.module;
+    return (
+      layer?.contactsWindowFromSnapshot?.(layer.getContextSnapshot?.()) ?? null
+    );
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the model-free fast World Packet from existing application owners.
+ *
+ * This performs no network requests and intentionally mirrors the historical
+ * get_current_view_state payload so voice can delegate without behavior drift.
+ */
+export function getWorldPacket(options = {}) {
+  const {
+    viewer,
+    styleManager,
+    dataManager,
+    sceneDirector = null,
+    now: requestedNow,
+  } = options ?? {};
+  // A default parameter only covers undefined; null or NaN would age every
+  // feed against the epoch and report stale data as "just now".
+  const now = Number.isFinite(requestedNow) ? requestedNow : Date.now();
+  if (!viewer?.camera?.positionWC)
+    throw new TypeError('World Packet requires a viewer camera');
+  if (!dataManager || typeof dataManager.getAll !== 'function')
+    throw new TypeError('World Packet requires a data manager');
+
+  const cartographic = Cesium.Cartographic.fromCartesian(
+    viewer.camera.positionWC,
+  );
+  // Read the roster once. Voice must not rewalk disabled layers: preserving the
+  // current enabled-only view keeps the model's context budget bounded.
+  const rows = dataManager.getAll();
+  const enabledRows = rows.filter((layer) => layer.enabled);
+  const contactsWindow = activeContactsWindow(dataManager);
+  const contextState =
+    typeof styleManager?.getContextModeState === 'function'
+      ? withContextModeVocabulary(styleManager.getContextModeState())
+      : null;
+
+  return {
+    ok: true,
+    action: 'get_current_view_state',
+    camera: {
+      latitude: Cesium.Math.toDegrees(cartographic.latitude),
+      longitude: Cesium.Math.toDegrees(cartographic.longitude),
+      heightM: cartographic.height,
+    },
+    style: styleManager?.activeStyle || 'normal',
+    context: contextState
+      ? {
+          ...contextState,
+          ...(contactsWindow ? { contactsWindow } : {}),
+        }
+      : null,
+    cockpit:
+      typeof styleManager?.getCockpitState === 'function'
+        ? styleManager.getCockpitState()
+        : null,
+    controls:
+      typeof styleManager?.getControlState === 'function'
+        ? styleManager.getControlState()
+        : null,
+    scenePlayback: sceneDirector?.getPlaybackStatus?.() || null,
+    tracked: collectTrackedEntities(dataManager),
+    disabledLayerCount: rows.length - enabledRows.length,
+    // Preserve get_current_view_state's existing compact enabled-only shape.
+    layers: enabledRows.map((layer) => {
+      const snapshot = layerSnapshot(layer, { now });
+      return {
+        id: layer.id,
+        name: layer.name,
+        enabled: layer.enabled,
+        count: layer.stats?.count || 0,
+        error: layer.stats?.error || null,
+        feedState: snapshot.feedState,
+        source: snapshot.source,
+        lastUpdate: snapshot.lastUpdate,
+      };
+    }),
+    feedProvenance: feedProvenanceEnvelope(
+      layerSnapshots(rows, { now }).filter((layer) => layer.enabled),
+      { now },
+    ),
+  };
+}

src/agent/worldPacket.test.mjs

@@ -0,0 +1,335 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as Cesium from 'cesium';
+
+import { getWorldPacket } from './worldPacket.js';
+import { createGevActionRunner } from '../voice/gevActions.js';
+
+function withoutVoicePresentation(result) {
+  const packet = { ...result };
+  delete packet.say;
+  delete packet.display;
+  delete packet.schedule;
+  return packet;
+}
+
+function harness() {
+  const position = Cesium.Cartesian3.fromDegrees(-97.74, 30.26, 500);
+  const viewer = {
+    trackedEntity: undefined,
+    clock: { onTick: { addEventListener: () => () => {} } },
+    scene: {
+      canvas: {
+        clientWidth: 1200,
+        clientHeight: 800,
+        addEventListener() {},
+        removeEventListener() {},
+      },
+      globe: { getHeight: () => 0 },
+      tweens: [],
+    },
+    camera: {
+      positionWC: position,
+      positionCartographic: Cesium.Cartographic.fromCartesian(position),
+      heading: 0,
+      pitch: Cesium.Math.toRadians(-45),
+      moveEnd: { addEventListener: () => () => {} },
+      cancelFlight() {},
+      lookAtTransform() {},
+    },
+  };
+  const rows = [
+    {
+      id: 'traffic',
+      name: 'Traffic',
+      enabled: true,
+      stats: {
+        count: 3,
+        source: 'fixture',
+        lastUpdate: null,
+      },
+    },
+  ];
+  const dataManager = {
+    layers: new Map([['traffic', { module: null }]]),
+    getAll: () => rows,
+  };
+  const styleManager = {
+    activeStyle: 'normal',
+    getContextModeState: () => ({ mode: 'flights' }),
+    getCockpitState: () => null,
+    getControlState: () => ({ hud: { visible: 'auto' } }),
+  };
+  return { viewer, dataManager, styleManager };
+}
+
+test('World Packet preserves get_current_view_state parity', async () => {
+  const { viewer, dataManager, styleManager } = harness();
+  const packet = getWorldPacket({ viewer, dataManager, styleManager });
+  const runner = createGevActionRunner({ viewer, dataManager, styleManager });
+  const voice = await runner('get_current_view_state');
+
+  assert.deepEqual(withoutVoicePresentation(voice), packet);
+  assert.equal(packet.context.mode, 'contacts');
+  assert.equal(packet.context.modeInternal, 'flights');
+  assert.equal(packet.layers[0].feedState, 'nominal');
+  assert.equal(packet.feedProvenance.overall, 'nominal');
+});
+
+test('World Packet keeps stale/unavailable feed semantics distinct from empty', () => {
+  const { viewer, dataManager, styleManager } = harness();
+  dataManager.getAll = () => [
+    {
+      id: 'traffic',
+      name: 'Traffic',
+      enabled: true,
+      stats: {
+        count: 0,
+        source: 'fixture',
+        error: 'fixture unavailable',
+        lastUpdate: null,
+      },
+    },
+  ];
+
+  const packet = getWorldPacket({ viewer, dataManager, styleManager });
+  assert.equal(packet.layers[0].count, 0);
+  assert.notEqual(packet.layers[0].feedState, 'nominal');
+  assert.notEqual(packet.feedProvenance.overall, 'nominal');
+  assert.match(packet.feedProvenance.note, /fixture unavailable/i);
+});
+
+// The 2026-10 main voice contract omits disabled layers from the model payload.
+test('World Packet and voice preserve enabled-only payload and count disabled layers', async () => {
+  const { viewer, dataManager, styleManager } = harness();
+  const rows = dataManager.getAll();
+  rows.push({
+    id: 'earthquakes',
+    name: 'Earthquakes',
+    enabled: false,
+    stats: { count: 99, source: 'fixture', error: 'stale' },
+  });
+  let reads = 0;
+  dataManager.getAll = () => {
+    reads += 1;
+    return rows;
+  };
+  const packet = getWorldPacket({ viewer, dataManager, styleManager });
+  assert.equal(reads, 1, 'collect the roster once rather than repeatedly');
+  assert.equal(packet.disabledLayerCount, 1);
+  assert.deepEqual(
+    packet.layers.map((layer) => layer.id),
+    ['traffic'],
+  );
+  assert.equal(packet.feedProvenance.overall, 'nominal');
+
+  const runner = createGevActionRunner({ viewer, dataManager, styleManager });
+  const voice = await runner('get_current_view_state');
+  assert.deepEqual(withoutVoicePresentation(voice), packet);
+});
+
+const PINNED_NOW = Date.UTC(2026, 9, 17, 12, 0, 0);
+
+// Exercises every packet field: context vocabulary and Contacts window,
+// cockpit, controls, scene playback, tracked families (one not ready),
+// enabled and disabled layers, and an aged and an unavailable feed.
+function pinnedHarness() {
+  const { viewer } = harness();
+  const rows = [
+    {
+      id: 'flights',
+      name: 'Flights',
+      enabled: true,
+      stats: {
+        count: 12,
+        source: 'fixture-adsb',
+        lastUpdate: PINNED_NOW - 90_000,
+      },
+    },
+    {
+      id: 'traffic',
+      name: 'Traffic',
+      enabled: true,
+      stats: {
+        count: 0,
+        source: 'fixture',
+        error: 'fixture unavailable',
+        lastUpdate: null,
+      },
+    },
+    {
+      id: 'earthquakes',
+      name: 'Earthquakes',
+      enabled: false,
+      stats: { count: 99, source: 'fixture', error: 'stale' },
+    },
+  ];
+  const module = (methods) => ({ module: methods });
+  const dataManager = {
+    layers: new Map([
+      [
+        'flights',
+        module({
+          getTrackedInfo: () => ({ icao24: 'abc123', callsign: 'TEST1' }),
+        }),
+      ],
+      [
+        'ais-live-vessels',
+        module({ getSelectedInfo: () => ({ mmsi: '366000001' }) }),
+      ],
+      [
+        'satellites',
+        module({
+          getTrackedInfo: () => {
+            throw new Error('not ready');
+          },
+        }),
+      ],
+      [
+        'military-awareness',
+        module({
+          getContextSnapshot: () => ({ snapshot: true }),
+          contactsWindowFromSnapshot: (snapshot) =>
+            snapshot ? { windowMin: 30, count: 4 } : null,
+        }),
+      ],
+    ]),
+    getAll: () => rows,
+  };
+  const styleManager = {
+    activeStyle: 'night-vision',
+    getContextModeState: () => ({
+      mode: 'flights',
+      entering: null,
+      priorMode: null,
+    }),
+    getCockpitState: () => ({ active: false }),
+    getControlState: () => ({ hud: { visible: 'auto' } }),
+  };
+  const sceneDirector = {
+    getPlaybackStatus: () => ({ playing: false, sceneId: 'fixture' }),
+  };
+  return { viewer, dataManager, styleManager, sceneDirector };
+}
+
+// Captured from main's get_current_view_state before the extraction
+// (bilawalsidhu/gods-eye-view@3d8e1ef0) with Date.now pinned to PINNED_NOW,
+// minus the speech envelope. Key order is part of the contract.
+const PRE_EXTRACTION_PAYLOAD = {
+  ok: true,
+  action: 'get_current_view_state',
+  camera: {
+    latitude: 30.259999999999994,
+    longitude: -97.74,
+    heightM: 499.99999999901877,
+  },
+  style: 'night-vision',
+  context: {
+    mode: 'contacts',
+    entering: null,
+    priorMode: null,
+    modeInternal: 'flights',
+    enteringInternal: null,
+    priorModeInternal: null,
+    contactsWindow: { windowMin: 30, count: 4 },
+  },
+  cockpit: { active: false },
+  controls: { hud: { visible: 'auto' } },
+  scenePlayback: { playing: false, sceneId: 'fixture' },
+  tracked: [
+    {
+      kind: 'aircraft',
+      layerId: 'flights',
+      icao24: 'abc123',
+      callsign: 'TEST1',
+    },
+    { kind: 'vessel', layerId: 'ais-live-vessels', mmsi: '366000001' },
+  ],
+  disabledLayerCount: 1,
+  layers: [
+    {
+      id: 'flights',
+      name: 'Flights',
+      enabled: true,
+      count: 12,
+      error: null,
+      feedState: 'nominal',
+      source: 'fixture-adsb',
+      lastUpdate: 1792238310000,
+    },
+    {
+      id: 'traffic',
+      name: 'Traffic',
+      enabled: true,
+      count: 0,
+      error: 'fixture unavailable',
+      feedState: 'unavailable',
+      source: 'fixture',
+      lastUpdate: 0,
+    },
+  ],
+  feedProvenance: {
+    overall: 'unavailable',
+    layers: [
+      {
+        id: 'flights',
+        name: 'Flights',
+        enabled: true,
+        feedState: 'nominal',
+        source: 'fixture-adsb',
+        count: 12,
+        lastUpdate: 1792238310000,
+        ageSec: 90,
+        ageLabel: '1m ago',
+        error: null,
+      },
+      {
+        id: 'traffic',
+        name: 'Traffic',
+        enabled: true,
+        feedState: 'unavailable',
+        source: 'fixture',
+        count: 0,
+        lastUpdate: 0,
+        ageSec: null,
+        ageLabel: null,
+        error: 'fixture unavailable',
+      },
+    ],
+    note: 'Traffic is UNAVAILABLE (fixture, fixture unavailable). Narrate that provenance with any count; do not describe this as live.',
+  },
+};
+
+function assertPinnedPayload(actual) {
+  assert.deepEqual(actual, PRE_EXTRACTION_PAYLOAD);
+  // deepEqual ignores key order; the serialized form does not.
+  assert.equal(JSON.stringify(actual), JSON.stringify(PRE_EXTRACTION_PAYLOAD));
+}
+
+test('World Packet matches the pre-extraction get_current_view_state payload', () => {
+  const packet = getWorldPacket({ ...pinnedHarness(), now: PINNED_NOW });
+  assertPinnedPayload(packet);
+});
+
+test('voice get_current_view_state still returns the pre-extraction payload', async (t) => {
+  t.mock.method(Date, 'now', () => PINNED_NOW);
+  const runner = createGevActionRunner(pinnedHarness());
+  const voice = await runner('get_current_view_state');
+  assertPinnedPayload(withoutVoicePresentation(voice));
+});
+
+test('World Packet ages feeds against the clock when now is not a finite number', (t) => {
+  t.mock.method(Date, 'now', () => PINNED_NOW);
+  for (const now of [null, Number.NaN, '2026-10-17']) {
+    const packet = getWorldPacket({ ...pinnedHarness(), now });
+    const flights = packet.feedProvenance.layers.find(
+      (layer) => layer.id === 'flights',
+    );
+    assert.equal(flights.ageSec, 90, `now: ${String(now)}`);
+    assert.equal(flights.ageLabel, '1m ago', `now: ${String(now)}`);
+  }
+});
+
+test('World Packet rejects null options with the camera requirement', () => {
+  assert.throws(() => getWorldPacket(null), /requires a viewer camera/);
+});

src/data/cctv.test.mjs

@@ -77,6 +77,11 @@ import {
   CCTV_FOCUS_REQUEST_EVENT,
   activateCctvCameraFromWorldClick,
 } from '../cctvFocusRequest.js';
+import {
+  ACTIVE_CAMERA_COLOR,
+  IDLE_CAMERA_COLOR,
+  LIVE_CAMERA_COLOR,
+} from '../layers/cctv/policy.js';
 
 const CCTV_PRESENTATION_SOURCE = fs.readFileSync(
   path.join(
@@ -360,6 +365,37 @@ test('default COVERAGE refresh materializes the active and visible camera frustu
   }
 });
 
+test('camera icons are violet for video feeds, cyan for stills, amber when active', () => {
+  const record = (id, feedType) => ({
+    camera: { ...UNCLAMPED_CAMERA, id, feedType, groundElevationM: 0 },
+    billboard: {},
+    coverageEntities: [],
+    projection: null,
+  });
+  const idleVideo = record('idle-hls', 'hls');
+  const idleStill = record('idle-image', 'image');
+  const activeVideo = record('active-hls', 'hls');
+  const viewer = { entities: { add: (entity) => entity } };
+
+  try {
+    // Disabled keeps the active video camera from opening a real projection;
+    // icon colors are assigned either way.
+    _setCctvCoverageStateForTest({
+      viewer,
+      records: [idleVideo, idleStill, activeVideo],
+      activeCameraId: activeVideo.camera.id,
+      enabled: false,
+      coverageMode: 'off',
+    });
+    refreshCoverageStyles();
+    assert.equal(idleVideo.billboard.color, LIVE_CAMERA_COLOR);
+    assert.equal(idleStill.billboard.color, IDLE_CAMERA_COLOR);
+    assert.equal(activeVideo.billboard.color, ACTIVE_CAMERA_COLOR);
+  } finally {
+    _setCctvCoverageStateForTest({ enabled: false });
+  }
+});
+
 test('geometry drain pacing yields to tracked and cockpit camera ownership', () => {
   assert.deepEqual(cctvGeometryDrainPacing(), { batchSize: 4, delayMs: 120 });
   assert.deepEqual(

src/data/cctvCatalogCap.test.mjs

@@ -6,6 +6,7 @@ import {
 } from '../../server/providers/cctv/cap.js';
 import {
   CCTV_MAX_SOURCES_CEILING,
+  CCTV_SOURCE_CACHE_MS,
   DEFAULT_CCTV_MAX_SOURCES,
 } from '../../server/providers/cctv/constants.js';
 import { createCctvCatalog } from '../../server/providers/cctv/catalog.js';
@@ -160,3 +161,224 @@ test('a pack trimmed to its nearest cameras reports how many it offered', async
   assert.equal(kept.available, 5);
   assert.deepEqual(kept.region, { west: 0, south: 0, east: 0, north: 4 });
 });
+
+/** A CCTV_SOURCES_JSON value with `count` cameras named `<prefix>-<i>`. */
+const envSources = (prefix, count = 3) =>
+  JSON.stringify(
+    Array.from({ length: count }, (_, i) => ({
+      id: `${prefix}-${i}`,
+      name: `${prefix} ${i}`,
+      lat: 30 + i * 0.01,
+      lon: -97,
+      url: `https://example.test/${prefix}-${i}.jpg`,
+    })),
+  );
+
+/** Let a background refresh that needs no timers run to completion. */
+const settle = () => new Promise((resolve) => setTimeout(resolve, 10));
+
+/** Restore process.env to a snapshot taken with `{ ...process.env }`. */
+const restoreEnv = (saved) => {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in saved)) delete process.env[key];
+  }
+  Object.assign(process.env, saved);
+};
+
+test('an expired catalog is served at once while a slow pack refreshes in the background', async (t) => {
+  const saved = { ...process.env };
+  try {
+    // Live packs run alongside the env pack, so one slow upstream can hold
+    // the refresh open.
+    process.env.CCTV_FORCE_AUSTIN = '1';
+    process.env.CCTV_SOURCES_FILE = '/nonexistent/cctv.json';
+    process.env.CCTV_SOURCES_JSON = envSources('old');
+    let now = 1_000_000;
+    t.mock.method(Date, 'now', () => now);
+    t.mock.method(console, 'warn', () => {});
+    t.mock.method(console, 'log', () => {});
+    const hung = [];
+    let hang = false;
+    t.mock.method(globalThis, 'fetch', () =>
+      hang
+        ? new Promise((_, reject) => {
+            hung.push(() => reject(new Error('upstream gave up')));
+          })
+        : Promise.reject(new Error('offline')),
+    );
+    const getSources = createCctvCatalog({ sourceRoot: '/nonexistent' });
+    assert.deepEqual(
+      (await getSources()).map((s) => s.id),
+      ['old-0', 'old-1', 'old-2'],
+    );
+
+    // Past the TTL, with every live pack's upstream hanging.
+    now += CCTV_SOURCE_CACHE_MS + 1;
+    hang = true;
+    process.env.CCTV_SOURCES_JSON = envSources('new');
+    let timer;
+    const served = await Promise.race([
+      getSources(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve('waited'), 200);
+      }),
+    ]);
+    clearTimeout(timer);
+    assert.notEqual(
+      served,
+      'waited',
+      'a stale request waited for the background refresh',
+    );
+    assert.deepEqual(
+      served.map((s) => s.id),
+      ['old-0', 'old-1', 'old-2'],
+    );
+
+    // Requests during the refresh share it rather than starting another.
+    const pause = () => new Promise((resolve) => setTimeout(resolve, 50));
+    await pause();
+    const inFlight = hung.length;
+    assert.ok(inFlight > 0, 'the refresh reached the hanging upstreams');
+    await getSources();
+    await getSources();
+    await pause();
+    assert.equal(hung.length, inFlight, 'only one refresh ran');
+
+    // When the slow pack gives up, the refreshed catalog replaces the old one.
+    hang = false;
+    for (const giveUp of hung) giveUp();
+    for (let i = 0; i < 50; i += 1) {
+      const ids = (await getSources()).map((s) => s.id);
+      if (ids[0] === 'new-0') break;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    assert.deepEqual(
+      (await getSources()).map((s) => s.id),
+      ['new-0', 'new-1', 'new-2'],
+    );
+  } finally {
+    restoreEnv(saved);
+  }
+});
+
+test('a failed background refresh keeps the catalog, warns once, and waits a TTL to retry', async (t) => {
+  const saved = { ...process.env };
+  const unhandled = [];
+  const onUnhandled = (reason) => unhandled.push(reason);
+  process.on('unhandledRejection', onUnhandled);
+  try {
+    process.env.CCTV_PREFER_AUSTIN = '0';
+    process.env.CCTV_SOURCES_FILE = '/nonexistent/cctv.json';
+    process.env.CCTV_SOURCES_JSON = envSources('old', 9);
+    process.env.CCTV_MAX_SOURCES = '8';
+    let now = 1_000_000;
+    t.mock.method(Date, 'now', () => now);
+    // Nine cameras over a cap of eight make every refresh warn; throwing from
+    // that warning is how this test makes a refresh reject.
+    let failRefresh = false;
+    let failedRefreshes = 0;
+    const warnings = [];
+    t.mock.method(console, 'warn', (...args) => {
+      const text = args.join(' ');
+      if (failRefresh && text.includes('exceeds cap')) {
+        failedRefreshes += 1;
+        throw new Error('refresh broke');
+      }
+      warnings.push(text);
+    });
+    const getSources = createCctvCatalog({ sourceRoot: '/nonexistent' });
+    const old = await getSources();
+    assert.equal(old.length, 8);
+
+    // Past the TTL the refresh throws: the old catalog is still served.
+    now += CCTV_SOURCE_CACHE_MS + 1;
+    failRefresh = true;
+    assert.equal(await getSources(), old);
+    await settle();
+    assert.equal(failedRefreshes, 1);
+    assert.equal(
+      warnings.filter((w) => w.includes('background catalog refresh failed'))
+        .length,
+      1,
+    );
+
+    // The failure is not retried on every request until the next TTL.
+    assert.equal(await getSources(), old);
+    assert.equal(await getSources(), old);
+    await settle();
+    assert.equal(failedRefreshes, 1, 'a failed refresh was retried at once');
+
+    // After it, a refresh that works replaces the catalog. With no live packs
+    // the refresh finishes before the request that started it returns.
+    now += CCTV_SOURCE_CACHE_MS + 1;
+    failRefresh = false;
+    process.env.CCTV_SOURCES_JSON = envSources('new');
+    await getSources();
+    await settle();
+    const fresh = await getSources();
+    assert.deepEqual(
+      fresh.map((s) => s.id),
+      ['new-0', 'new-1', 'new-2'],
+    );
+    // Trim notes stay with the list they describe, so a request served the
+    // old list during the refresh never reports the new list's notes.
+    assert.deepEqual(
+      getSources.trimmedPacks(old).map((p) => [p.pack, p.available, p.served]),
+      [['env', 9, 8]],
+    );
+    assert.deepEqual(getSources.trimmedPacks(fresh), []);
+    assert.deepEqual(getSources.trimmedPacks(), []);
+    assert.deepEqual(unhandled, []);
+  } finally {
+    process.off('unhandledRejection', onUnhandled);
+    restoreEnv(saved);
+  }
+});
+
+test('an empty background refresh keeps the catalog and waits a TTL before fetching again', async (t) => {
+  const saved = { ...process.env };
+  try {
+    process.env.CCTV_FORCE_AUSTIN = '1';
+    process.env.CCTV_SOURCES_FILE = '/nonexistent/cctv.json';
+    process.env.CCTV_SOURCES_JSON = envSources('old');
+    let now = 1_000_000;
+    t.mock.method(Date, 'now', () => now);
+    t.mock.method(console, 'log', () => {});
+    const warnings = [];
+    t.mock.method(console, 'warn', (...args) => warnings.push(args.join(' ')));
+    let fetches = 0;
+    t.mock.method(globalThis, 'fetch', () => {
+      fetches += 1;
+      return Promise.reject(new Error('offline'));
+    });
+    const getSources = createCctvCatalog({ sourceRoot: '/nonexistent' });
+    const old = await getSources();
+
+    // Past the TTL every pack comes back empty, as in an upstream outage.
+    now += CCTV_SOURCE_CACHE_MS + 1;
+    process.env.CCTV_SOURCES_JSON = '[]';
+    assert.equal(await getSources(), old);
+    for (let i = 0; i < 50; i += 1) {
+      if (warnings.some((w) => w.includes('source refresh returned empty')))
+        break;
+      await settle();
+    }
+    assert.ok(
+      warnings.some((w) => w.includes('serving 3 stale cameras')),
+      'the empty refresh kept the old catalog',
+    );
+
+    // Until the next TTL, requests are served without touching any upstream.
+    const fetchesAfterRefresh = fetches;
+    assert.equal(await getSources(), old);
+    assert.equal(await getSources(), old);
+    await settle();
+    assert.equal(
+      fetches,
+      fetchesAfterRefresh,
+      'an empty refresh reran at once',
+    );
+  } finally {
+    restoreEnv(saved);
+  }
+});

src/data/cctvEstonia.test.mjs

@@ -2,6 +2,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   loadTallinnSourcesFromCatalog,
+  loadTarkteeSourcesFromDatex,
   parseTarkteeDatexImages,
   parseTarkteeDatexLocations,
 } from '../../server/providers/cctv/sources.js';
@@ -84,3 +85,26 @@ test('Tarktee DATEX image parser rejects non-official hosts', () => {
   const images = parseTarkteeDatexImages(xml);
   assert.equal(images.size, 0);
 });
+
+test('Tarktee DATEX requests wait 30 s, past the slow answers measured live', async (t) => {
+  const timeouts = [];
+  const timeout = AbortSignal.timeout;
+  t.mock.method(AbortSignal, 'timeout', (ms) => {
+    timeouts.push(ms);
+    return timeout.call(AbortSignal, ms);
+  });
+  t.mock.method(console, 'log', () => {});
+  t.mock.method(
+    globalThis,
+    'fetch',
+    async (url) =>
+      new Response(
+        String(url).includes('roadCameraLocations')
+          ? SAMPLE_LOCATIONS_XML
+          : SAMPLE_IMAGES_XML,
+      ),
+  );
+  const cameras = await loadTarkteeSourcesFromDatex();
+  assert.deepEqual(timeouts, [30_000, 30_000]);
+  assert.equal(cameras.length, 1);
+});

src/geminiComposition.test.mjs

@@ -0,0 +1,115 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { localProviderPlugins } from '../server/providers/local.js';
+import { standaloneVoiceTools } from '../server/standalone/voiceTools.js';
+import {
+  KEY_SETUP_KEYS,
+  keySetupStatus,
+  validateKeySetupUpdates,
+  upsertDotenvValues,
+} from './keySetupCore.mjs';
+
+test('local hosts opt into Gemini explicitly and retain the default plugin order', (t) => {
+  t.mock.method(globalThis, 'fetch', () => {
+    throw Error('construction must not fetch');
+  });
+  const defaults = localProviderPlugins().map((plugin) => plugin.name);
+  assert.ok(!defaults.includes('gemini-live-proxy'));
+  const enabled = localProviderPlugins({ gemini: {} }).map(
+    (plugin) => plugin.name,
+  );
+  assert.equal(
+    enabled.filter((name) => name === 'gemini-live-proxy').length,
+    1,
+  );
+  assert.deepEqual(
+    enabled.filter((name) => name !== 'gemini-live-proxy'),
+    defaults,
+  );
+});
+
+for (const hook of ['configureServer', 'configurePreviewServer']) {
+  test(`opted-in ${hook} locks the standalone catalog into the Gemini token`, async () => {
+    const tools = standaloneVoiceTools();
+    const calls = [];
+    const plugin = localProviderPlugins({
+      gemini: {
+        tools,
+        resolveApiKey: () => 'fixture-key',
+        resolveModel: () => 'gemini-3.8-live',
+        resolveHost: () => '',
+        resolveAllowedHosts: () => '',
+        resolveRateLimit: () => '0',
+        fetchImpl: async (url, options) => {
+          calls.push({ url, options });
+          return Response.json({ name: 'auth_tokens/fixture' });
+        },
+      },
+    }).find((entry) => entry.name === 'gemini-live-proxy');
+    let handler;
+    plugin[hook]({
+      middlewares: {
+        use(route, value) {
+          assert.equal(route, '/api/gemini/token');
+          handler = value;
+        },
+      },
+    });
+    const req = new PassThrough();
+    req.method = 'POST';
+    req.headers = {
+      host: 'localhost:5173',
+      origin: 'http://localhost:5173',
+      'content-type': 'application/json',
+    };
+    req.socket = { remoteAddress: '127.0.0.1' };
+    const res = new EventEmitter();
+    res.setHeader = () => {};
+    res.end = (body) => {
+      res.body = JSON.parse(body);
+      res.writableEnded = true;
+    };
+    req.end('{}');
+    await handler(req, res);
+    assert.equal(res.statusCode, 200);
+    assert.equal(calls.length, 1);
+    const locked = JSON.parse(calls[0].options.body).bidiGenerateContentSetup
+      .tools[0].functionDeclarations;
+    assert.deepEqual(
+      locked.map(({ name }) => name),
+      tools.map(({ name }) => name),
+    );
+    assert.deepEqual(
+      locked.map(({ parametersJsonSchema }) => parametersJsonSchema),
+      tools.map(({ parameters }) => parameters),
+    );
+    assert.ok(locked.every(({ behavior }) => behavior === 'BLOCKING'));
+    assert.deepEqual(res.body.config.tools[0].functionDeclarations, locked);
+    assert.ok(!JSON.stringify(res.body).includes('fixture-key'));
+  });
+}
+
+test('Gemini key setup uses the existing server-only status and save contract', () => {
+  const entry = KEY_SETUP_KEYS.find(({ id }) => id === 'gemini');
+  assert.deepEqual(entry.envVars, ['GEMINI_API_KEY']);
+  assert.ok(!entry.clientExposed);
+  assert.equal(
+    keySetupStatus({}).keys.find(({ id }) => id === 'gemini').set,
+    false,
+  );
+  const env = { GEMINI_API_KEY: 'fixture-private-key' };
+  const status = keySetupStatus(env);
+  assert.equal(status.keys.find(({ id }) => id === 'gemini').set, true);
+  assert.ok(!JSON.stringify(status).includes(env.GEMINI_API_KEY));
+  assert.equal(validateKeySetupUpdates(env).ok, true);
+  assert.match(
+    upsertDotenvValues('GEMINI_API_KEY=old\n', env),
+    /^GEMINI_API_KEY=fixture-private-key\n$/,
+  );
+  assert.equal(
+    validateKeySetupUpdates({ VITE_GEMINI_API_KEY: 'fixture-private-key' }).ok,
+    false,
+  );
+});

src/i18n/locales/es.json

@@ -2890,5 +2890,56 @@
   "USB work abandoned after a stalled transfer": "Trabajo USB cancelado tras una transferencia bloqueada",
   "SDR decoder did not start; receiver stopped": "El decodificador SDR no arrancó; receptor detenido",
   "SDR decoder stopped responding; receiver stopped": "El decodificador SDR dejó de responder; receptor detenido",
-  "SDR decoder fell behind; receiver stopped": "El decodificador SDR se quedó atrás; receptor detenido"
+  "SDR decoder fell behind; receiver stopped": "El decodificador SDR se quedó atrás; receptor detenido",
+  "Gemini returned an oversized audio chunk": "Gemini devolvió un fragmento de audio demasiado grande",
+  "Gemini returned an unsupported audio format": "Gemini devolvió un formato de audio no compatible",
+  "Gemini returned an invalid audio sample rate": "Gemini devolvió una frecuencia de muestreo de audio no válida",
+  "Gemini returned incomplete PCM audio": "Gemini devolvió audio PCM incompleto",
+  "This browser does not support Gemini microphone audio": "Este navegador no admite audio del micrófono para Gemini",
+  "Microphone audio processing failed": "Falló el procesamiento del audio del micrófono",
+  "Gemini audio playback fell behind. Reconnect to continue.": "La reproducción de audio de Gemini se ha retrasado. Vuelve a conectar para continuar.",
+  "Gemini token response did not include an ephemeral credential": "La respuesta de Gemini no incluyó una credencial temporal",
+  "Invalid Gemini connection endpoint": "El destino de conexión de Gemini no es válido",
+  "Voice command context is too large": "El contexto del comando de voz es demasiado grande",
+  "Gemini reliable transport exceeded its queue limit. Start voice again.": "La cola de envío fiable de Gemini superó su límite. Vuelve a iniciar la voz.",
+  "Gemini reliable transport did not drain. Start voice again.": "La cola de envío fiable de Gemini no se vació. Vuelve a iniciar la voz.",
+  "Gemini token request failed (HTTP {status})": "Falló la solicitud de credencial de Gemini (HTTP {status})",
+  "Gemini token response did not include a valid model": "La respuesta de Gemini no incluyó un modelo válido",
+  "Gemini token response did not include session settings": "La respuesta de Gemini no incluyó la configuración de la sesión",
+  "Gemini session settings do not match the input mode": "La configuración de la sesión de Gemini no coincide con el modo de entrada",
+  "Gemini could not submit this input. Start voice again.": "Gemini no pudo enviar esta entrada. Vuelve a iniciar la voz.",
+  "Connecting to Gemini": "Conectando con Gemini",
+  "Gemini returned an oversized message": "Gemini devolvió un mensaje demasiado grande",
+  "Gemini Live connection failed. Check network access, then start voice again.": "Falló la conexión con Gemini Live. Comprueba el acceso a la red y vuelve a iniciar la voz.",
+  "Gemini Live connection ended. Start voice again for a new conversation.": "La conexión con Gemini Live terminó. Vuelve a iniciar la voz para una nueva conversación.",
+  "Gemini Live could not start. Start voice again to request a fresh session.": "Gemini Live no pudo iniciarse. Vuelve a iniciar la voz para solicitar una nueva sesión.",
+  "Start voice again for a fresh token and a new conversation.": "Vuelve a iniciar la voz para obtener una credencial nueva y comenzar otra conversación.",
+  "Start voice again to request a fresh session credential.": "Vuelve a iniciar la voz para solicitar una nueva credencial de sesión.",
+  "Microphone permission was denied. Allow microphone access and try again.": "Se denegó el permiso del micrófono. Permite el acceso al micrófono e inténtalo de nuevo.",
+  "Gemini connection timed out. Try again.": "Se agotó el tiempo de conexión con Gemini. Inténtalo de nuevo.",
+  "Gemini voice could not start": "No se pudo iniciar la voz de Gemini",
+  "Gemini did not finish the interrupted reply. Start voice again.": "Gemini no terminó la respuesta interrumpida. Vuelve a iniciar la voz.",
+  "Gemini session expiring; finishing the current reply": "La sesión de Gemini va a caducar; terminando la respuesta actual",
+  "Gemini rejected the voice session. Start voice again to request a fresh session.": "Gemini rechazó la sesión de voz. Vuelve a iniciar la voz para solicitar una nueva sesión.",
+  "Start voice again for a fresh session credential. If it repeats, check Gemini model and API access.": "Vuelve a iniciar la voz para obtener una nueva credencial de sesión. Si se repite, comprueba el modelo de Gemini y el acceso a la API.",
+  "Gemini action history is full. Start voice again for a fresh session.": "El historial de acciones de Gemini está lleno. Vuelve a iniciar la voz para una nueva sesión.",
+  "Gemini requested too many simultaneous actions": "Gemini solicitó demasiadas acciones simultáneas",
+  "Voice text command is too long": "El comando de voz escrito es demasiado largo",
+  "Gemini voice is not connected": "La voz de Gemini no está conectada",
+  "Gemini interrupted input exceeded its buffer or wait limit. Start voice again.": "La entrada interrumpida de Gemini superó el límite de búfer o de espera. Vuelve a iniciar la voz.",
+  "Gemini Live connection is expiring. Start voice again for a new conversation.": "La conexión con Gemini Live va a caducar. Vuelve a iniciar la voz para una nueva conversación.",
+  "Gemini voice sessions have a time limit. When a session expires, start voice again for a new conversation.": "Las sesiones de voz de Gemini tienen un límite de tiempo. Cuando caduque la sesión, vuelve a iniciar la voz para una nueva conversación.",
+  "Gemini Live voice control": "Control por voz con Gemini Live",
+  "Voice provider": "Proveedor de voz",
+  "Changing provider reconnects voice if it is on.": "Cambiar de proveedor vuelve a conectar la voz si está activada.",
+  "Gemini voice could not connect. Try again.": "No se pudo conectar la voz de Gemini. Inténtalo de nuevo.",
+  "Gemini voice requires a same-origin app request": "La voz de Gemini requiere una solicitud del mismo origen que la aplicación",
+  "Add a Gemini API key in Provider Settings": "Añade una clave de API de Gemini en los ajustes de proveedores",
+  "The Gemini Live model configuration is invalid": "La configuración del modelo de Gemini Live no es válida",
+  "Gemini voice is starting too often. Try again shortly.": "La voz de Gemini se está iniciando con demasiada frecuencia. Vuelve a intentarlo en breve.",
+  "Gemini quota is unavailable. Try again later.": "La cuota de Gemini no está disponible. Inténtalo más tarde.",
+  "Gemini access was refused. Check the API key and model access.": "Se denegó el acceso a Gemini. Comprueba la clave de API y el acceso al modelo.",
+  "Gemini Live is unavailable for the configured model.": "Gemini Live no está disponible para el modelo configurado.",
+  "Token request is too large": "La solicitud de credencial es demasiado grande",
+  "Use an empty JSON token request": "Usa una solicitud de credencial con un objeto JSON vacío"
 }

src/i18n/locales/ru.json

@@ -2957,5 +2957,56 @@
   "USB work abandoned after a stalled transfer": "Работа с USB прервана: передача данных зависла",
   "SDR decoder did not start; receiver stopped": "Декодер SDR не запустился; приёмник остановлен",
   "SDR decoder stopped responding; receiver stopped": "Декодер SDR перестал отвечать; приёмник остановлен",
-  "SDR decoder fell behind; receiver stopped": "Декодер SDR не успевает; приёмник остановлен"
+  "SDR decoder fell behind; receiver stopped": "Декодер SDR не успевает; приёмник остановлен",
+  "Gemini returned an oversized audio chunk": "Gemini вернул слишком большой фрагмент аудио",
+  "Gemini returned an unsupported audio format": "Gemini вернул неподдерживаемый формат аудио",
+  "Gemini returned an invalid audio sample rate": "Gemini вернул недопустимую частоту дискретизации аудио",
+  "Gemini returned incomplete PCM audio": "Gemini вернул неполные аудиоданные PCM",
+  "This browser does not support Gemini microphone audio": "Этот браузер не поддерживает звук с микрофона для Gemini",
+  "Microphone audio processing failed": "Не удалось обработать звук с микрофона",
+  "Gemini audio playback fell behind. Reconnect to continue.": "Воспроизведение звука Gemini отстаёт. Подключитесь заново, чтобы продолжить.",
+  "Gemini token response did not include an ephemeral credential": "В ответе Gemini нет временных учётных данных",
+  "Invalid Gemini connection endpoint": "Недопустимый адрес подключения к Gemini",
+  "Voice command context is too large": "Контекст голосовой команды слишком велик",
+  "Gemini reliable transport exceeded its queue limit. Start voice again.": "Очередь надёжной передачи Gemini превысила лимит. Запустите голосовой режим заново.",
+  "Gemini reliable transport did not drain. Start voice again.": "Очередь надёжной передачи Gemini не освободилась. Запустите голосовой режим заново.",
+  "Gemini token request failed (HTTP {status})": "Не удалось запросить токен Gemini (HTTP {status})",
+  "Gemini token response did not include a valid model": "В ответе Gemini нет допустимой модели",
+  "Gemini token response did not include session settings": "В ответе Gemini нет настроек сеанса",
+  "Gemini session settings do not match the input mode": "Настройки сеанса Gemini не соответствуют режиму ввода",
+  "Gemini could not submit this input. Start voice again.": "Gemini не удалось отправить эти данные. Запустите голосовой режим заново.",
+  "Connecting to Gemini": "Подключение к Gemini",
+  "Gemini returned an oversized message": "Gemini вернул слишком большое сообщение",
+  "Gemini Live connection failed. Check network access, then start voice again.": "Не удалось подключиться к Gemini Live. Проверьте доступ к сети и запустите голосовой режим заново.",
+  "Gemini Live connection ended. Start voice again for a new conversation.": "Соединение с Gemini Live завершено. Запустите голосовой режим заново для нового разговора.",
+  "Gemini Live could not start. Start voice again to request a fresh session.": "Не удалось запустить Gemini Live. Запустите голосовой режим заново, чтобы запросить новый сеанс.",
+  "Start voice again for a fresh token and a new conversation.": "Запустите голосовой режим заново, чтобы получить новый токен и начать новый разговор.",
+  "Start voice again to request a fresh session credential.": "Запустите голосовой режим заново, чтобы запросить новые учётные данные сеанса.",
+  "Microphone permission was denied. Allow microphone access and try again.": "Доступ к микрофону запрещён. Разрешите доступ и повторите попытку.",
+  "Gemini connection timed out. Try again.": "Время ожидания подключения к Gemini истекло. Повторите попытку.",
+  "Gemini voice could not start": "Не удалось запустить голосовой режим Gemini",
+  "Gemini did not finish the interrupted reply. Start voice again.": "Gemini не завершил прерванный ответ. Запустите голосовой режим заново.",
+  "Gemini session expiring; finishing the current reply": "Сеанс Gemini истекает; завершается текущий ответ",
+  "Gemini rejected the voice session. Start voice again to request a fresh session.": "Gemini отклонил голосовой сеанс. Запустите голосовой режим заново, чтобы запросить новый сеанс.",
+  "Start voice again for a fresh session credential. If it repeats, check Gemini model and API access.": "Запустите голосовой режим заново для получения новых учётных данных. Если ошибка повторится, проверьте модель Gemini и доступ к API.",
+  "Gemini action history is full. Start voice again for a fresh session.": "История действий Gemini заполнена. Запустите голосовой режим заново для нового сеанса.",
+  "Gemini requested too many simultaneous actions": "Gemini запросил слишком много одновременных действий",
+  "Voice text command is too long": "Текст голосовой команды слишком длинный",
+  "Gemini voice is not connected": "Голосовой режим Gemini не подключён",
+  "Gemini interrupted input exceeded its buffer or wait limit. Start voice again.": "Прерванный ввод Gemini превысил лимит буфера или ожидания. Запустите голосовой режим заново.",
+  "Gemini Live connection is expiring. Start voice again for a new conversation.": "Соединение с Gemini Live истекает. Запустите голосовой режим заново для нового разговора.",
+  "Gemini voice sessions have a time limit. When a session expires, start voice again for a new conversation.": "Время голосовых сеансов Gemini ограничено. Когда сеанс истечёт, запустите голосовой режим заново для нового разговора.",
+  "Gemini Live voice control": "Голосовое управление через Gemini Live",
+  "Voice provider": "Поставщик голосового сервиса",
+  "Changing provider reconnects voice if it is on.": "Смена поставщика переподключает голосовой режим, если он включён.",
+  "Gemini voice could not connect. Try again.": "Не удалось подключить голосовой режим Gemini. Повторите попытку.",
+  "Gemini voice requires a same-origin app request": "Голосовой режим Gemini требует запрос из того же источника, что и приложение",
+  "Add a Gemini API key in Provider Settings": "Добавьте ключ API Gemini в настройках поставщиков",
+  "The Gemini Live model configuration is invalid": "Недопустимая конфигурация модели Gemini Live",
+  "Gemini voice is starting too often. Try again shortly.": "Голосовой режим Gemini запускается слишком часто. Повторите попытку чуть позже.",
+  "Gemini quota is unavailable. Try again later.": "Квота Gemini недоступна. Повторите попытку позже.",
+  "Gemini access was refused. Check the API key and model access.": "Доступ к Gemini запрещён. Проверьте ключ API и доступ к модели.",
+  "Gemini Live is unavailable for the configured model.": "Gemini Live недоступен для выбранной модели.",
+  "Token request is too large": "Запрос токена слишком велик",
+  "Use an empty JSON token request": "Используйте запрос токена с пустым объектом JSON"
 }

src/keySetupCore.mjs

@@ -19,7 +19,7 @@ import { hasProxySignals } from './localRequestGate.mjs';
 /** Longest accepted key/token value. Real provider keys are all far shorter. */
 export const KEY_SETUP_VALUE_LIMIT = 512;
 
-/** Most env vars accepted in one save. The registry defines ten. */
+/** Most env vars accepted in one save. */
 export const KEY_SETUP_UPDATE_LIMIT = 16;
 
 /** Header line written above keys the panel appends to a .env file. */
@@ -65,6 +65,14 @@ export const KEY_SETUP_KEYS = Object.freeze([
     envVars: Object.freeze(['OPENAI_API_KEY']),
     tier: 'metered',
   }),
+  Object.freeze({
+    id: 'gemini',
+    title: 'GEMINI', // i18n-ignore: provider product name
+    unlocks: msg('Gemini Live voice control'),
+    getUrl: 'https://aistudio.google.com/apikey',
+    envVars: Object.freeze(['GEMINI_API_KEY']),
+    tier: 'metered',
+  }),
   Object.freeze({
     id: 'aisstream',
     title: 'AISSTREAM', // i18n-ignore: provider product name

src/layers/cctv/frames.js

@@ -3,6 +3,7 @@ import {
   FRAME_SIGNATURE_H,
   PROJECTION_CANVAS_WIDTH,
   PROJECTION_CANVAS_HEIGHT,
+  PROJECTION_MATTE_COLOR,
   PROJECTION_TEXTURE_SWAP_MS,
   ACTIVE_FRAME_REFRESH_MS,
   FRAME_ENDPOINT,
@@ -12,6 +13,37 @@ import {
   PLACEHOLDER_REPAINT_MS,
 } from './policy.js';
 
+/**
+ * Contain-fits a source frame into the projection canvas: scaled to the
+ * largest size that fits, centered, with the margins left for the matte fill.
+ * Falls back to the full canvas when either dimension is missing or zero.
+ *
+ * @param {number} sourceW - Source width in pixels.
+ * @param {number} sourceH - Source height in pixels.
+ * @returns {{x:number,y:number,w:number,h:number}} Draw rectangle in canvas pixels.
+ */
+export function fitToProjection(sourceW, sourceH) {
+  if (!sourceW || !sourceH)
+    return {
+      x: 0,
+      y: 0,
+      w: PROJECTION_CANVAS_WIDTH,
+      h: PROJECTION_CANVAS_HEIGHT,
+    };
+  const scale = Math.min(
+    PROJECTION_CANVAS_WIDTH / sourceW,
+    PROJECTION_CANVAS_HEIGHT / sourceH,
+  );
+  const w = Math.round(sourceW * scale);
+  const h = Math.round(sourceH * scale);
+  return {
+    x: Math.round((PROJECTION_CANVAS_WIDTH - w) / 2),
+    y: Math.round((PROJECTION_CANVAS_HEIGHT - h) / 2),
+    w,
+    h,
+  };
+}
+
 export function createFrames({ state: layerState, services, parts, source }) {
   /**
    * FNV-1a over the RGB channels of a downsampled frame. Pure (takes the raw
@@ -182,7 +214,7 @@ export function createFrames({ state: layerState, services, parts, source }) {
     ctx.clearRect(0, 0, w, h);
     const g = ctx.createLinearGradient(0, 0, w, h);
     g.addColorStop(0, '#05111a');
-    g.addColorStop(1, '#01070c');
+    g.addColorStop(1, PROJECTION_MATTE_COLOR);
     ctx.fillStyle = g;
     ctx.fillRect(0, 0, w, h);
 
@@ -320,7 +352,14 @@ export function createFrames({ state: layerState, services, parts, source }) {
         // base color (planeMaterial color = WHITE, alpha .95) for the frame or
         // two Cesium needs to rebind, which IS the periodic white flash from the
         // owner field tests (2026-07-04 and 2026-07-30).
-        const signature = projectionFrameSignature(runtime);
+        const fit = fitToProjection(
+          runtime.image.naturalWidth,
+          runtime.image.naturalHeight,
+        );
+        // Pixels are hashed at a fixed size, so the fit carries the aspect.
+        const pixels = projectionFrameSignature(runtime);
+        const signature =
+          pixels === null ? null : `${pixels}:${fit.w}x${fit.h}`;
         runtime.drawnImageStamp = runtime.imageStamp;
         if (signature !== null && signature === runtime.lastFrameSignature) {
           // Identical pixels — leave the canvas, and therefore the bound
@@ -328,19 +367,14 @@ export function createFrames({ state: layerState, services, parts, source }) {
           return;
         }
         runtime.lastFrameSignature = signature;
-        runtime.ctx.clearRect(
-          0,
-          0,
-          PROJECTION_CANVAS_WIDTH,
-          PROJECTION_CANVAS_HEIGHT,
-        );
-        runtime.ctx.drawImage(
-          runtime.image,
+        runtime.ctx.fillStyle = PROJECTION_MATTE_COLOR;
+        runtime.ctx.fillRect(
           0,
           0,
           PROJECTION_CANVAS_WIDTH,
           PROJECTION_CANVAS_HEIGHT,
         );
+        runtime.ctx.drawImage(runtime.image, fit.x, fit.y, fit.w, fit.h);
         runtime.canvasStamp = (runtime.canvasStamp || 0) + 1;
         runtime.lastPlaceholderPaintAt = 0;
       }

src/layers/cctv/frames.test.mjs

@@ -0,0 +1,141 @@
+// src/layers/cctv/frames.test.mjs
+// Still-frame fit (#1201): stills draw at their source aspect, centered on the
+// 1920x1080 projection canvas, instead of being stretched to fill it.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createFrames, fitToProjection } from './frames.js';
+import {
+  FRAME_SIGNATURE_W,
+  FRAME_SIGNATURE_H,
+  PROJECTION_CANVAS_WIDTH,
+  PROJECTION_CANVAS_HEIGHT,
+  PROJECTION_MATTE_COLOR,
+} from './policy.js';
+
+// The expected rectangles below are written for a 1920x1080 canvas.
+assert.equal(PROJECTION_CANVAS_WIDTH, 1920);
+assert.equal(PROJECTION_CANVAS_HEIGHT, 1080);
+
+const FULL_CANVAS = {
+  x: 0,
+  y: 0,
+  w: PROJECTION_CANVAS_WIDTH,
+  h: PROJECTION_CANVAS_HEIGHT,
+};
+
+test('a 4:3 still is pillarboxed at full height', () => {
+  assert.deepEqual(fitToProjection(640, 480), {
+    x: 240,
+    y: 0,
+    w: 1440,
+    h: 1080,
+  });
+});
+
+test('a source wider than 16:9 is letterboxed at full width', () => {
+  assert.deepEqual(fitToProjection(3840, 1080), {
+    x: 0,
+    y: 270,
+    w: 1920,
+    h: 540,
+  });
+});
+
+test('a 16:9 still fills the canvas', () => {
+  assert.deepEqual(fitToProjection(1920, 1080), FULL_CANVAS);
+});
+
+test('a missing or zero dimension falls back to the full canvas', () => {
+  assert.deepEqual(fitToProjection(0, 480), FULL_CANVAS);
+  assert.deepEqual(fitToProjection(640, 0), FULL_CANVAS);
+  assert.deepEqual(fitToProjection(640, undefined), FULL_CANVAS);
+  assert.deepEqual(fitToProjection(undefined, undefined), FULL_CANVAS);
+});
+
+// Draw path: the fit reaches drawImage, and the unchanged-frame skip keys on the
+// fitted size as well as the pixels (the 64x36 hash alone drops aspect).
+function stillHarness() {
+  const calls = [];
+  const ctx = {
+    fillStyle: null,
+    fillRect: (...rect) => calls.push(['fillRect', ctx.fillStyle, ...rect]),
+    clearRect: () => {},
+    drawImage: (_image, ...rect) => calls.push(['drawImage', ...rect]),
+  };
+  // Every frame downsamples to the same pixels, so only the size differs.
+  const pixels = new Uint8ClampedArray(
+    FRAME_SIGNATURE_W * FRAME_SIGNATURE_H * 4,
+  ).fill(7);
+  const runtime = {
+    mode: 'image',
+    ctx,
+    image: { naturalWidth: 0, naturalHeight: 0 },
+    imageReady: true,
+    // In flight, so refreshProjectionImage returns before touching image.src.
+    imageLoading: true,
+    imageStamp: 0,
+    drawnImageStamp: -1,
+    lastFrameSignature: null,
+    canvasStamp: 0,
+    signatureCtx: {
+      clearRect: () => {},
+      drawImage: () => {},
+      getImageData: () => ({ data: pixels }),
+    },
+  };
+  const record = { camera: { id: 'still' }, projection: runtime };
+  const { drawProjectionFrame } = createFrames({
+    state: { _healthById: new Map(), _activeCameraId: null },
+    services: {},
+    parts: {},
+    source: {},
+  });
+  const load = (width, height) => {
+    runtime.image = { naturalWidth: width, naturalHeight: height };
+    runtime.imageStamp += 1;
+    calls.length = 0;
+    drawProjectionFrame(record);
+    return calls.slice();
+  };
+  return { runtime, load };
+}
+
+test('a still is drawn into its fitted rectangle over a full matte', () => {
+  const { runtime, load } = stillHarness();
+  assert.deepEqual(load(640, 480), [
+    [
+      'fillRect',
+      PROJECTION_MATTE_COLOR,
+      0,
+      0,
+      PROJECTION_CANVAS_WIDTH,
+      PROJECTION_CANVAS_HEIGHT,
+    ],
+    ['drawImage', 240, 0, 1440, 1080],
+  ]);
+  assert.equal(runtime.canvasStamp, 1);
+});
+
+test('same pixels at the same size skip the redraw', () => {
+  const { runtime, load } = stillHarness();
+  load(640, 480);
+  assert.deepEqual(load(640, 480), []);
+  assert.equal(runtime.canvasStamp, 1);
+});
+
+test('same pixels at a new aspect redraw at the new fit', () => {
+  const { runtime, load } = stillHarness();
+  load(640, 480);
+  assert.deepEqual(load(1920, 1080), [
+    [
+      'fillRect',
+      PROJECTION_MATTE_COLOR,
+      0,
+      0,
+      PROJECTION_CANVAS_WIDTH,
+      PROJECTION_CANVAS_HEIGHT,
+    ],
+    ['drawImage', 0, 0, 1920, 1080],
+  ]);
+  assert.equal(runtime.canvasStamp, 2);
+});

src/layers/cctv/policy.js

@@ -35,6 +35,9 @@ export const PROJECTION_CANVAS_WIDTH = 1920;
 
 export const PROJECTION_CANVAS_HEIGHT = 1080;
 
+/** Matte behind fitted stills; the placeholder gradient's dark end. */
+export const PROJECTION_MATTE_COLOR = '#01070c';
+
 // Downsample grid for the unchanged-frame signature (drawProjectionFrame).
 // 64x36 keeps the 16:9 aspect and reads ~9 KB per check versus the 8.3 MB a
 // full-resolution compare would touch.
@@ -410,6 +413,9 @@ export const IDLE_CAMERA_COLOR =
 export const ACTIVE_CAMERA_COLOR =
   Cesium.Color.fromCssColorString('#ffd97a').withAlpha(0.95);
 
+export const LIVE_CAMERA_COLOR =
+  Cesium.Color.fromCssColorString('#b48cff').withAlpha(0.88);
+
 export const IDLE_COVERAGE_COLOR =
   Cesium.Color.fromCssColorString('#2fe0ff').withAlpha(0.24);
 

src/layers/cctv/rendering.js

@@ -4,6 +4,7 @@ import { isHeadingEstimated } from './headingConfidence.js';
 import {
   ACTIVE_CAMERA_COLOR,
   IDLE_CAMERA_COLOR,
+  LIVE_CAMERA_COLOR,
   ACTIVE_COVERAGE_CENTER,
   IDLE_COVERAGE_CENTER_MUTED,
   ACTIVE_COVERAGE_CENTER_DEPTHFAIL,
@@ -18,6 +19,15 @@ export function createRendering({
   parts,
   source,
 }) {
+  /** Icon color: active wins, then live-capable video feeds, then idle stills. */
+  function cameraColorFor(record) {
+    if (record.camera.id === layerState._activeCameraId)
+      return ACTIVE_CAMERA_COLOR;
+    if (parts.model.isVideoFeedType(record.camera.feedType))
+      return LIVE_CAMERA_COLOR;
+    return IDLE_CAMERA_COLOR;
+  }
+
   const {
     focusNowMs,
     getFocusTarget,
@@ -58,10 +68,7 @@ export function createRendering({
         ),
       cameraDistanceFor: (position) =>
         Cesium.Cartesian3.distance(camera.positionWC, position),
-      baseColorFor: (record) =>
-        record.camera.id === layerState._activeCameraId
-          ? ACTIVE_CAMERA_COLOR
-          : IDLE_CAMERA_COLOR,
+      baseColorFor: cameraColorFor,
     });
     layerState._activeFocusStyleCount = result.activeCount;
   }
@@ -208,9 +215,7 @@ export function createRendering({
     for (const record of layerState._records) {
       const isActive = record.camera.id === activeId;
       if (record.billboard) {
-        record.billboard.color = isActive
-          ? ACTIVE_CAMERA_COLOR
-          : IDLE_CAMERA_COLOR;
+        record.billboard.color = cameraColorFor(record);
         record.billboard.scale = isActive ? 1.25 : 1.0;
         // disableDepthTestDistance stays POSITIVE_INFINITY for every billboard
         // (set at creation) — see the field-test far-zoom submerge fix there.

src/layers/cctv/rendering.test.mjs

@@ -0,0 +1,73 @@
+// src/layers/cctv/rendering.test.mjs
+// Icon colors under focus de-emphasis (#1200): the focus pass fades each icon
+// from the same base color the coverage refresh assigns, so a video-feed camera
+// stays violet while it dims instead of falling back to the idle cyan.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRendering } from './rendering.js';
+import {
+  ACTIVE_CAMERA_COLOR,
+  IDLE_CAMERA_COLOR,
+  LIVE_CAMERA_COLOR,
+} from './policy.js';
+import { isVideoFeedType } from '../../sources/cctvTypes.js';
+
+const FOCUS_FACTOR = 0.5;
+
+function assertFadedFrom(actual, base, label) {
+  assert.ok(actual, `${label}: color written`);
+  assert.deepEqual(
+    [actual.red, actual.green, actual.blue],
+    [base.red, base.green, base.blue],
+    `${label}: hue`,
+  );
+  assert.equal(actual.alpha, base.alpha * FOCUS_FACTOR, `${label}: alpha`);
+}
+
+test('focus de-emphasis fades each icon from its own color', () => {
+  const record = (id, feedType) => ({
+    camera: { id, feedType },
+    // No position, so the pass skips screen projection; the focus stub below
+    // decides the factor on its own.
+    billboard: { show: true },
+  });
+  const idleVideo = record('idle-hls', 'hls');
+  const idleStill = record('idle-image', 'image');
+  const activeVideo = record('active-hls', 'hls');
+  const state = {
+    _enabled: true,
+    _viewer: { scene: {}, camera: {} },
+    _records: [idleVideo, idleStill, activeVideo],
+    _activeCameraId: activeVideo.camera.id,
+    _activeFocusStyleCount: 0,
+    _lastFocusStyleAt: -Infinity,
+  };
+  const focus = {
+    focusNowMs: (nowMs) => nowMs,
+    getFocusTarget: () => ({}),
+    focusPassIsNeeded: () => true,
+    advanceSpriteFocus: () => ({
+      factor: FOCUS_FACTOR,
+      active: true,
+      transitioning: false,
+    }),
+    focusAlphaNeedsWrite: () => true,
+  };
+  const { refreshCctvFocusStyles } = createRendering({
+    state,
+    services: { focus },
+    parts: { model: { isVideoFeedType } },
+    source: {},
+  });
+
+  refreshCctvFocusStyles(1000);
+
+  assertFadedFrom(idleVideo.billboard.color, LIVE_CAMERA_COLOR, 'idle video');
+  assertFadedFrom(idleStill.billboard.color, IDLE_CAMERA_COLOR, 'idle still');
+  assertFadedFrom(
+    activeVideo.billboard.color,
+    ACTIVE_CAMERA_COLOR,
+    'active video',
+  );
+  assert.equal(state._activeFocusStyleCount, 3);
+});

src/navigationPolicyFrame.test.mjs

@@ -6,6 +6,7 @@ import { readdirSync, readFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { TRACKABLE_FAMILIES } from './agent/worldPacket.js';
 import { setLocale } from './i18n/index.js';
 import {
   COCKPIT_REFUSAL_NOUNS,
@@ -68,10 +69,8 @@ const NOUN_LITERAL =
   /\bnoun\s*=\s*'([^']+)'|\bconst noun\s*=\s*[^?;]*\?\s*'([^']+)'\s*:\s*'([^']+)'/g;
 
 function trackableKinds() {
-  const source = readFileSync(join(SRC, 'voice/gevActions.js'), 'utf8');
-  const block = source.match(/const TRACKABLE_FAMILIES = \[([\s\S]*?)\];/);
-  assert.ok(block, 'TRACKABLE_FAMILIES is still in gevActions.js');
-  return [...block[1].matchAll(/kind:\s*'([^']+)'/g)].map((m) => m[1]);
+  // This is shared with voice; test the exported owner, not its file position.
+  return TRACKABLE_FAMILIES.map(({ kind }) => kind);
 }
 
 // Non-literal arguments: what each one can be. A wrapper's own `noun` (or all

src/standalone/tools.js

@@ -17,6 +17,10 @@ export function createStandaloneTools(options) {
       },
     },
     ...options,
-    voice: { toolCatalog: loadToolCatalog, ...options?.voice },
+    voice: {
+      supportedProviders: ['openai', 'gemini'],
+      toolCatalog: loadToolCatalog,
+      ...options?.voice,
+    },
   });
 }

src/testSupport/geminiIntegrationFixture.mjs

@@ -0,0 +1,364 @@
+import assert from 'node:assert/strict';
+import { createVoiceSession } from '../voice/session.js';
+import { createGevActionRunner } from '../voice/gevActions.js';
+import { createGeminiSession } from '../voice/geminiSession.js';
+import { createNarrationScheduler } from '../voice/narration.js';
+
+export const turnOfEventLoop = () =>
+  new Promise((resolve) => setImmediate(resolve));
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+function ownedClock() {
+  let now = 0;
+  let nextId = 0;
+  const timers = new Map();
+  return {
+    timers,
+    now: () => now,
+    setTimer(fn, delay = 0) {
+      const id = ++nextId;
+      timers.set(id, { fn, at: now + Math.max(0, delay) });
+      return id;
+    },
+    clearTimer: (id) => timers.delete(id),
+    advance(ms) {
+      const until = now + ms;
+      let callbacks = 0;
+      for (;;) {
+        const due = [...timers]
+          .filter(([, timer]) => timer.at <= until)
+          .sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0];
+        if (!due) break;
+        assert.ok(
+          ++callbacks <= 1000,
+          'fixture timer queue must remain bounded',
+        );
+        timers.delete(due[0]);
+        now = due[1].at;
+        due[1].fn();
+      }
+      now = until;
+    },
+  };
+}
+
+/**
+ * Real common session -> real Gemini adapter -> real action runner.
+ * Only devices, transport, passive UI and wall-clock facilities are fakes.
+ * The optional result gate delays return AFTER the actual action commits.
+ */
+export function nativeIntegrationFixture(t) {
+  const clock = ownedClock();
+  const events = [];
+  const sockets = [];
+  const tracks = [];
+  const audios = [];
+  const requests = [];
+  const runnerCalls = [];
+  const runnerJobs = [];
+  const resultGates = new Map();
+  const acquisitions = { microphone: 0, audio: 0, token: 0, socket: 0 };
+  const state = { height: 1000, renders: 0, zooms: [], earconStarts: 0 };
+  const position = { x: 6379137, y: 0, z: 0 };
+  const viewer = {
+    clock: { onTick: { addEventListener: () => () => {} } },
+    camera: {
+      positionWC: position,
+      positionCartographic: { height: state.height },
+      moveEnd: { addEventListener() {} },
+      cancelFlight() {},
+      zoomIn(metres) {
+        position.x -= metres;
+        state.height -= metres;
+        this.positionCartographic.height = state.height;
+        state.zooms.push({ direction: 'in', metres });
+      },
+      zoomOut(metres) {
+        position.x += metres;
+        state.height += metres;
+        this.positionCartographic.height = state.height;
+        state.zooms.push({ direction: 'out', metres });
+      },
+    },
+    scene: {
+      canvas: {
+        clientWidth: 800,
+        clientHeight: 600,
+        addEventListener() {},
+        removeEventListener() {},
+      },
+      requestRender() {
+        state.renders++;
+      },
+    },
+  };
+  const dataManager = { layers: new Map() };
+  const actualRunner = createGevActionRunner({
+    viewer,
+    dataManager,
+    styleManager: {},
+  });
+  const runner = (name, args, options) => {
+    runnerCalls.push({ name, args, options });
+    const job = (async () => {
+      // No fake action result: the camera and envelope come from production.
+      const result = await actualRunner(name, args, options);
+      const gate = resultGates.get(options.callId);
+      if (gate) {
+        gate.entered.resolve(result);
+        await gate.release.promise;
+      }
+      return result;
+    })();
+    runnerJobs.push(job);
+    return job;
+  };
+  class Socket {
+    constructor(url) {
+      acquisitions.socket++;
+      this.url = url;
+      this.readyState = 0;
+      this.bufferedAmount = 0;
+      this.sent = [];
+      sockets.push(this);
+      queueMicrotask(() => {
+        if (this.closed) return;
+        this.readyState = 1;
+        this.onopen?.();
+      });
+    }
+    send(raw) {
+      assert.equal(
+        this.readyState,
+        1,
+        'sending requires the owned open socket',
+      );
+      const message = JSON.parse(raw);
+      this.sent.push(message);
+      if (message.setup)
+        queueMicrotask(() => this.message({ setupComplete: {} }));
+    }
+    message(message) {
+      this.onmessage?.({ data: JSON.stringify(message) });
+    }
+    close() {
+      this.closed = true;
+      this.readyState = 3;
+    }
+  }
+  const session = createVoiceSession({
+    runner,
+    createAdapter: (hooks) =>
+      createGeminiSession({
+        ...hooks,
+        ui: { root: { remove() {} } },
+        dataManager,
+        now: clock.now,
+        setTimer: clock.setTimer,
+        clearTimer: clock.clearTimer,
+        WebSocketClass: Socket,
+        getUserMedia: async () => {
+          acquisitions.microphone++;
+          const track = {
+            enabled: true,
+            readyState: 'live',
+            stopCalls: 0,
+            stop() {
+              this.stopCalls++;
+              this.readyState = 'ended';
+            },
+          };
+          tracks.push(track);
+          return { getTracks: () => [track], getAudioTracks: () => [track] };
+        },
+        fetchImpl: async (url, init) => {
+          acquisitions.token++;
+          requests.push({ url, init });
+          const manual = JSON.parse(init.body).inputMode === 'push-to-talk';
+          return Response.json({
+            token: 'auth_tokens/fixture-not-a-credential',
+            model: 'gemini-3.8-live',
+            websocketUrl:
+              'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContentConstrained',
+            config: {
+              generationConfig: { responseModalities: ['AUDIO'] },
+              ...(manual
+                ? {
+                    realtimeInputConfig: {
+                      automaticActivityDetection: { disabled: true },
+                    },
+                  }
+                : {}),
+            },
+          });
+        },
+        createInput: ({ readStream, operations }) => ({
+          ...operations,
+          setMicrophoneEnabled(enabled) {
+            for (const track of readStream()?.getAudioTracks() || [])
+              track.enabled = enabled;
+          },
+          updateVoiceButtonLabel() {},
+          setVoiceSpeaker() {},
+          startVoiceVisualizer() {},
+          startAssistantVoiceVisualizer() {},
+          cancelPushToTalkHold() {},
+          stopVoiceVisualizer() {},
+          detachBindings() {},
+          bindPushToTalkShortcut() {},
+          resetSession() {
+            this.pushToTalkMode =
+              this.pushToTalkKeyHeld =
+              this.spaceKeyHeld =
+                false;
+          },
+        }),
+        createAudio: (callbacks) => {
+          acquisitions.audio++;
+          const audio = {
+            pending: false,
+            closed: false,
+            outputStream: {},
+            async initialize() {},
+            connectMicrophone(stream, enabled, metadata) {
+              this.stream = stream;
+              this.setMicrophoneEnabled(enabled, metadata);
+            },
+            setMicrophoneEnabled(enabled, metadata) {
+              this.enabled = enabled;
+              this.metadata = metadata;
+            },
+            play() {
+              this.pending = true;
+            },
+            clearPlayback() {
+              this.pending = false;
+            },
+            drain() {
+              this.pending = false;
+              callbacks.onDrain();
+            },
+            diagnostics: () => ({ outputChunks: 0 }),
+            async close() {
+              this.closed = true;
+              this.pending = false;
+              return true;
+            },
+          };
+          audios.push(audio);
+          return audio;
+        },
+        createNarration: (options) =>
+          createNarrationScheduler({
+            ...options,
+            now: clock.now,
+            setTimer: clock.setTimer,
+            clearTimer: clock.clearTimer,
+          }),
+        createProgressEarcon: () => ({
+          available: () => true,
+          start() {
+            state.earconStarts++;
+          },
+          stop() {},
+          dispose() {},
+        }),
+        captureViewport: async () => null,
+      }),
+  });
+  session.subscribe((event) => events.push(event));
+  const controller = session.adapter.controller;
+  t.after(async () => {
+    session.destroy();
+    for (const gate of resultGates.values()) gate.release.resolve();
+    await Promise.allSettled(runnerJobs);
+    actualRunner.dispose();
+    assert.equal(clock.timers.size, 0, 'fixture must leave no owned timer');
+    assert.ok(audios.every((audio) => audio.closed));
+    assert.ok(tracks.every((track) => track.readyState === 'ended'));
+    assert.ok(sockets.every((socket) => socket.closed));
+  });
+  return {
+    session,
+    controller,
+    state,
+    events,
+    sockets,
+    tracks,
+    audios,
+    requests,
+    acquisitions,
+    runnerCalls,
+    clock,
+    holdResult(callId) {
+      const gate = { entered: deferred(), release: deferred() };
+      resultGates.set(callId, gate);
+      return { ready: gate.entered.promise, release: gate.release.resolve };
+    },
+    async start() {
+      await session.start();
+      assert.equal(session.state, 'listening');
+      assert.equal(controller.getDiagnostics().connected, true);
+      return sockets.at(-1);
+    },
+    activity(socket = sockets.at(-1)) {
+      socket.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+      socket.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+    },
+    tool(callId, socket = sockets.at(-1)) {
+      socket.message({
+        toolCall: {
+          functionCalls: [
+            {
+              id: callId,
+              name: 'adjust_camera_zoom',
+              args: { direction: 'in', amount: 'little' },
+            },
+          ],
+        },
+      });
+      // A deterministic settlement boundary, not a fake action dispatcher.
+      return controller.toolQueue;
+    },
+    outputs(socket = sockets.at(-1)) {
+      return socket.sent.flatMap(
+        (message) => message.toolResponse?.functionResponses || [],
+      );
+    },
+    complete(socket = sockets.at(-1)) {
+      socket.message({ serverContent: { turnComplete: true } });
+    },
+  };
+}
+
+export function assertSuccessfulZoom(h, socket, callId, beforeHeight) {
+  assert.equal(h.state.height, beforeHeight * 0.75);
+  assert.ok(h.state.renders > 0);
+  const calls = h.events.filter(
+    (event) => event.type === 'action-call' && event.callId === callId,
+  );
+  const results = h.events.filter(
+    (event) => event.type === 'action-result' && event.callId === callId,
+  );
+  assert.equal(calls.length, 1);
+  assert.equal(results.length, 1);
+  assert.equal(calls[0].name, 'adjust_camera_zoom');
+  assert.deepEqual(calls[0].arguments, { direction: 'in', amount: 'little' });
+  assert.equal(results[0].result.ok, true);
+  assert.equal(results[0].result.action, 'adjust_camera_zoom');
+  assert.equal(results[0].result.beforeHeightM, Math.round(beforeHeight));
+  assert.equal(results[0].result.afterHeightM, Math.round(h.state.height));
+  const outputs = h.outputs(socket).filter((output) => output.id === callId);
+  assert.equal(outputs.length, 1);
+  assert.equal(outputs[0].name, 'adjust_camera_zoom');
+  assert.equal(outputs[0].response.ok, true);
+  assert.equal(outputs[0].response.action, 'adjust_camera_zoom');
+  assert.equal(outputs[0].response.afterHeightM, Math.round(h.state.height));
+}

src/testSupport/geminiNativeHarness.mjs

@@ -0,0 +1,251 @@
+import { GeminiSessionController } from '../voice/geminiSession.js';
+import { createNarrationScheduler } from '../voice/narration.js';
+
+const endpoint =
+  'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContentConstrained';
+const credential = {
+  token: 'auth_tokens/test',
+  model: 'gemini-3.8-live',
+  websocketUrl: endpoint,
+  config: { generationConfig: { responseModalities: ['AUDIO'] } },
+};
+const manualCredential = {
+  ...credential,
+  config: {
+    ...credential.config,
+    realtimeInputConfig: { automaticActivityDetection: { disabled: true } },
+  },
+};
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+function harness(overrides = {}) {
+  const { autoSetup = true, ...controllerOverrides } = overrides;
+  const events = [];
+  const sockets = [];
+  const media = [];
+  const tracks = [];
+  const captures = [];
+  const calls = [];
+  const requests = [];
+  const state = { playing: 0, ducked: false, stopped: 0 };
+  let clock = 0;
+  let nextTimer = 0;
+  const timers = new Map();
+  const earcon = { playing: false, starts: 0, disposals: 0 };
+  const advance = (ms) => {
+    const target = clock + ms;
+    for (;;) {
+      const due = [...timers]
+        .filter(([, timer]) => timer.at <= target)
+        .sort((a, b) => a[1].at - b[1].at)[0];
+      if (!due) break;
+      timers.delete(due[0]);
+      clock = due[1].at;
+      due[1].fn();
+    }
+    clock = target;
+  };
+  let radioControl;
+  const radio = {
+    setVoiceDucked(value) {
+      state.ducked = value;
+    },
+    pause() {},
+    subscribePlaybackControls(callback) {
+      radioControl = callback;
+      return () => {
+        radioControl = null;
+      };
+    },
+    async playForVoice() {
+      state.playing++;
+      return true;
+    },
+    stopPlayback() {
+      state.stopped++;
+    },
+  };
+  class Socket {
+    constructor(url) {
+      this.url = url;
+      this.readyState = 0;
+      this.bufferedAmount = 0;
+      this.sent = [];
+      sockets.push(this);
+      queueMicrotask(() => {
+        this.readyState = 1;
+        this.onopen?.();
+      });
+    }
+    send(raw) {
+      const value = JSON.parse(raw);
+      this.sent.push(value);
+      if (value.setup && autoSetup)
+        queueMicrotask(() => this.message({ setupComplete: {} }));
+    }
+    message(value) {
+      this.onmessage?.({ data: JSON.stringify(value) });
+    }
+    error() {
+      this.onerror?.();
+    }
+    remoteClose() {
+      this.readyState = 3;
+      this.onclose?.();
+    }
+    close() {
+      this.readyState = 3;
+      this.closed = true;
+    }
+  }
+  const makeStream = () => {
+    const track = {
+      enabled: true,
+      readyState: 'live',
+      stop() {
+        this.readyState = 'ended';
+      },
+    };
+    tracks.push(track);
+    return { getTracks: () => [track], getAudioTracks: () => [track] };
+  };
+  const c = new GeminiSessionController({
+    emit: (event) => events.push(event),
+    runAction: async (name, args, options) => {
+      calls.push({ name, args, options });
+      return { ok: true, action: name };
+    },
+    ui: { root: { remove() {} } },
+    radioLayer: radio,
+    now: () => clock,
+    setTimer: (fn, ms) => {
+      const id = ++nextTimer;
+      timers.set(id, { fn, at: clock + ms });
+      return id;
+    },
+    clearTimer: (id) => timers.delete(id),
+    WebSocketClass: Socket,
+    fetchImpl: async (_url, init) => {
+      requests.push(init);
+      return Response.json(
+        JSON.parse(init.body).inputMode === 'push-to-talk'
+          ? manualCredential
+          : credential,
+      );
+    },
+    getUserMedia: async () => makeStream(),
+    createInput: ({ readStream, operations }) => ({
+      ...operations,
+      setMicrophoneEnabled(enabled) {
+        for (const track of readStream()?.getAudioTracks() || [])
+          track.enabled = enabled;
+      },
+      updateVoiceButtonLabel() {},
+      setVoiceSpeaker() {},
+      startVoiceVisualizer() {},
+      startAssistantVoiceVisualizer() {},
+      cancelPushToTalkHold() {},
+      stopVoiceVisualizer() {},
+      detachBindings() {},
+      bindPushToTalkShortcut() {},
+      resetSession() {
+        this.pushToTalkMode = false;
+        this.pushToTalkKeyHeld = false;
+        this.spaceKeyHeld = false;
+      },
+    }),
+    createNarration: (options) =>
+      createNarrationScheduler({
+        ...options,
+        now: () => clock,
+        setTimer: (fn, ms) => {
+          const id = ++nextTimer;
+          timers.set(id, { fn, at: clock + ms });
+          return id;
+        },
+        clearTimer: (id) => timers.delete(id),
+      }),
+    createProgressEarcon: ({ isMicrophoneMuted }) => ({
+      available: isMicrophoneMuted,
+      start() {
+        earcon.playing = true;
+        earcon.starts++;
+      },
+      stop() {
+        earcon.playing = false;
+      },
+      dispose() {
+        this.stop();
+        earcon.disposals++;
+      },
+    }),
+    createAudio: (callbacks) => {
+      const audio = {
+        callbacks,
+        pending: false,
+        closed: false,
+        played: [],
+        async initialize() {},
+        connectMicrophone(stream, enabled, metadata) {
+          media.push({ stream, enabled });
+          this.connected = true;
+          this.setMicrophoneEnabled(enabled, metadata);
+        },
+        setMicrophoneEnabled(value, metadata) {
+          if (!this.connected) return;
+          if (value && !this.enabled) {
+            this.metadata = metadata;
+            callbacks.onAudioStart(metadata);
+          }
+          if (!value && this.enabled) callbacks.onAudioEnd(this.metadata);
+          this.enabled = value;
+        },
+        play(data, mime) {
+          this.pending = true;
+          this.played.push({ data, mime });
+        },
+        drain() {
+          this.pending = false;
+          callbacks.onDrain();
+        },
+        clearPlayback() {
+          this.pending = false;
+          this.cleared = true;
+        },
+        diagnostics() {
+          return { outputChunks: this.played.length };
+        },
+        close() {
+          this.closed = true;
+        },
+      };
+      captures.push(audio);
+      return audio;
+    },
+    ...controllerOverrides,
+  });
+  return {
+    c,
+    sockets,
+    tracks,
+    makeStream,
+    events,
+    media,
+    captures,
+    calls,
+    requests,
+    state,
+    advance,
+    timers,
+    earcon,
+    radioControl: (value) => radioControl?.(value),
+  };
+}
+
+export { harness, tick, deferred };

src/tooling/viteBuild.test.mjs

@@ -88,8 +88,19 @@ test('root config retains existing named exports and standalone provider order',
   for (const [name, value] of Object.entries(providers))
     assert.equal(compatibility[name], value, name);
   const config = standaloneConfig({ mode: 'test' });
+  const standaloneProviders = config.plugins
+    .slice(3, -5)
+    .map((plugin) => plugin.name);
+  assert.equal(
+    standaloneProviders.filter((name) => name === 'gemini-live-proxy').length,
+    1,
+  );
+  assert.equal(
+    standaloneProviders.indexOf('gemini-live-proxy'),
+    standaloneProviders.indexOf('openai-realtime-proxy') + 1,
+  );
   assert.deepEqual(
-    config.plugins.slice(3, -5).map((plugin) => plugin.name),
+    standaloneProviders.filter((name) => name !== 'gemini-live-proxy'),
     providers.localProviderPlugins().map((plugin) => plugin.name),
   );
   assert.equal(config.plugins.at(-6).name, 'gev-key-setup');

src/ui/panelChrome.js

@@ -72,7 +72,8 @@ export class PanelChrome {
         variant: this.hud.getVariant(),
       }),
       scheduleCockpitLayout: () => this.cockpitView?.scheduleContextLayout(),
-      syncPanelCollapseButton: (panel) => this._syncPanelCollapseButton(panel),
+      syncPanelCollapseButton: (panel) =>
+        this._syncRailPanelCollapseButton(panel),
       readDisplayScrollTop: () =>
         this._displayPortalScrollRestoreOwner === 'standard'
           ? this._standardDisplayScrollTop
@@ -287,6 +288,19 @@ export class PanelChrome {
     return this._panelLayout._scheduleLeftPanelLayout(options0);
   }
 
+  _syncRailPanelCollapseButton(panelEl) {
+    // Adaptive rail layout may directly restore an auto-collapsed Context
+    // without invoking setPanelCollapsed(). Enforce Radio ownership there too.
+    if (
+      panelEl?.id === 'global-context-panel' &&
+      !panelEl.classList.contains('collapsed') &&
+      this._contextRadioDock?.classList.contains('disclosure-open')
+    ) {
+      this._setRadioDisclosure?.(false);
+    }
+    this._syncPanelCollapseButton(panelEl);
+  }
+
   _syncPanelCollapseButton(panelEl) {
     const isRightRail = [
       'pp-toggles',
@@ -501,6 +515,15 @@ export class PanelChrome {
         syncShare,
       });
     }
+    // A repeated Context-open request must clear a stale compact Radio mini
+    // even when no collapsed class changes.
+    if (
+      !nextCollapsed &&
+      panelId === 'global-context-panel' &&
+      this._contextRadioDock?.classList.contains('disclosure-open')
+    ) {
+      this._setRadioDisclosure?.(false);
+    }
     if (
       panelEl.classList.contains('collapsed') === nextCollapsed &&
       !wasAutoCollapsed

src/ui/panelChrome.radioOwnership.test.mjs

@@ -0,0 +1,200 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { PanelChrome } from './panelChrome.js';
+import { PanelLayoutController } from './panelLayoutController.js';
+
+function classList(initial = []) {
+  const values = new Set(initial);
+  return {
+    contains: (value) => values.has(value),
+    add: (...items) => items.forEach((item) => values.add(item)),
+    remove: (...items) => items.forEach((item) => values.delete(item)),
+    toggle(value, force) {
+      if (force === true) values.add(value);
+      else if (force === false) values.delete(value);
+      else if (values.has(value)) values.delete(value);
+      else values.add(value);
+      return values.has(value);
+    },
+  };
+}
+
+test('opening an already-open Context still closes a stale compact Radio disclosure', (t) => {
+  const priorDocument = globalThis.document;
+  const contextPanel = {
+    id: 'global-context-panel',
+    classList: classList(),
+  };
+  globalThis.document = {
+    documentElement: { dataset: { uiTheme: 'tactical' } },
+    getElementById(id) {
+      return id === 'global-context-panel' ? contextPanel : null;
+    },
+  };
+  t.after(() => {
+    globalThis.document = priorDocument;
+  });
+
+  const radioDock = { classList: classList(['disclosure-open']) };
+  const calls = [];
+  const owner = {
+    _contextRadioDock: radioDock,
+    _setRadioDisclosure(open) {
+      calls.push(open);
+      radioDock.classList.toggle('disclosure-open', open);
+    },
+    _leftPanelStack: null,
+    _rightPanelStack: null,
+    _panelLayout: {
+      _leftStackPreferredPanelId: null,
+      _rightStackPreferredPanelId: null,
+    },
+    _syncPanelCollapseButton() {},
+    _scheduleLeftPanelLayout() {},
+    _scheduleRightPanelLayout() {},
+    shareLinkManager: null,
+    cockpitView: null,
+  };
+
+  PanelChrome.prototype.setPanelCollapsed.call(
+    owner,
+    'global-context-panel',
+    false,
+  );
+
+  assert.deepEqual(calls, [false]);
+  assert.equal(radioDock.classList.contains('disclosure-open'), false);
+});
+
+test('adaptive rail restore hides compact Radio before revealing Context', (t) => {
+  const priorRaf = globalThis.requestAnimationFrame;
+  let nextFrame;
+  globalThis.requestAnimationFrame = (callback) => {
+    nextFrame = callback;
+    return 1;
+  };
+  t.after(() => {
+    globalThis.requestAnimationFrame = priorRaf;
+  });
+
+  // Valid starting state: the tactical rail automatically collapsed Context,
+  // and the user opened the compact Radio controls from its header.
+  const contextPanel = {
+    id: 'global-context-panel',
+    classList: classList(['collapsed', 'layout-auto-collapsed']),
+  };
+  const radioDock = { classList: classList(['disclosure-open']) };
+  const radioMini = { hidden: false };
+  const calls = [];
+  const chrome = {
+    _contextRadioDock: radioDock,
+    _setRadioDisclosure(open) {
+      calls.push(`disclosure:${open}`);
+      radioDock.classList.toggle('disclosure-open', open);
+      radioMini.hidden = !open;
+    },
+    _syncPanelCollapseButton(panel) {
+      calls.push(`button:${panel.id}`);
+    },
+  };
+  const layout = {
+    destroyed: false,
+    _rightStackLayoutFrame: null,
+    _rightStackReconsiderAutoCollapse: false,
+    _rightPanelStack: {
+      querySelectorAll: (selector) =>
+        selector === '.layout-auto-collapsed' ? [contextPanel] : [],
+    },
+    _syncPanelCollapseButton(panel) {
+      PanelChrome.prototype._syncRailPanelCollapseButton.call(chrome, panel);
+    },
+    _syncRightPanelAdaptiveLayout() {
+      calls.push('layout');
+    },
+  };
+
+  PanelLayoutController.prototype._scheduleRightPanelLayout.call(layout, {
+    reconsiderAutoCollapse: true,
+  });
+  assert.equal(contextPanel.classList.contains('collapsed'), true);
+  assert.equal(radioMini.hidden, false);
+  nextFrame();
+
+  assert.equal(contextPanel.classList.contains('collapsed'), false);
+  assert.equal(contextPanel.classList.contains('layout-auto-collapsed'), false);
+  assert.equal(radioDock.classList.contains('disclosure-open'), false);
+  assert.equal(radioMini.hidden, true);
+  assert.deepEqual(calls, [
+    'disclosure:false',
+    'button:global-context-panel',
+    'layout',
+  ]);
+});
+
+test('real PanelChrome constructor wires rail restore to compact Radio owner', (t) => {
+  const priorDocument = globalThis.document;
+  const priorRaf = globalThis.requestAnimationFrame;
+  let nextFrame;
+  const contextPanel = {
+    id: 'global-context-panel',
+    classList: classList(['collapsed', 'layout-auto-collapsed']),
+  };
+  const rightRail = {
+    querySelectorAll(selector) {
+      return selector === '.layout-auto-collapsed' ? [contextPanel] : [];
+    },
+  };
+  globalThis.document = {
+    getElementById(id) {
+      return id === 'right-context-rail' ? rightRail : null;
+    },
+  };
+  globalThis.requestAnimationFrame = (callback) => {
+    nextFrame = callback;
+    return 1;
+  };
+  t.after(() => {
+    globalThis.document = priorDocument;
+    globalThis.requestAnimationFrame = priorRaf;
+  });
+
+  const dock = { classList: classList(['disclosure-open']) };
+  const calls = [];
+  const chrome = new PanelChrome({
+    elements: { _contextRadioDock: dock },
+    operations: {
+      _setRadioDisclosure(open) {
+        calls.push(`disclosure:${open}`);
+        dock.classList.toggle('disclosure-open', open);
+      },
+      _syncPanelCollapseButton(panel) {
+        calls.push(`button:${panel.id}`);
+      },
+    },
+    readHud: () => ({ visible: true, getVariant: () => 'tactical' }),
+    readCockpit: () => null,
+    readShareLinks: () => null,
+    readInitialShare: () => null,
+    readScrollRestoreOwner: () => null,
+    readDisplayScrollTop: () => 0,
+  });
+  chrome._panelLayout._syncRightPanelAdaptiveLayout = () => {
+    calls.push('layout');
+  };
+
+  chrome._panelLayout._scheduleRightPanelLayout({
+    reconsiderAutoCollapse: true,
+  });
+  assert.equal(typeof nextFrame, 'function');
+  assert.equal(dock.classList.contains('disclosure-open'), true);
+  nextFrame();
+
+  assert.equal(contextPanel.classList.contains('collapsed'), false);
+  assert.equal(dock.classList.contains('disclosure-open'), false);
+  assert.deepEqual(calls, [
+    'disclosure:false',
+    'button:global-context-panel',
+    'layout',
+  ]);
+});

src/ui/styles/voice-cost.css

@@ -140,3 +140,95 @@ html:not([lang='en'])
   white-space: normal;
   overflow-wrap: anywhere;
 }
+
+#gev-voice-control[data-provider-choice='true'] {
+  --gev-provider-lift: 0px;
+}
+
+/* Provider choice belongs to the existing voice control, not a separate panel. */
+.gev-voice-provider-field {
+  position: absolute;
+  bottom: calc(100% + var(--gev-provider-lift, 0px));
+  z-index: 9;
+  left: 0;
+  right: 0;
+  display: grid;
+  gap: 4px;
+  padding: 8px 6px;
+  border: 1px solid var(--glass-border);
+  border-radius: 8px;
+  background: var(--bg-panel, #09121b);
+  color: var(--text-secondary);
+  font-family: var(--font-mono);
+  font-size: 0.5rem;
+  opacity: 0;
+  pointer-events: none;
+}
+.gev-voice-provider-field[hidden] {
+  display: none;
+}
+.gev-voice-provider-field select {
+  min-width: 0;
+  width: 100%;
+  min-height: 30px;
+  color: var(--text-primary);
+  background: #09121b;
+  border: 1px solid var(--glass-border);
+  border-radius: 4px;
+  font: inherit;
+  font-size: 0.65rem;
+}
+#gev-voice-control:hover .gev-voice-provider-field,
+#gev-voice-control:focus-within .gev-voice-provider-field {
+  opacity: 1;
+  pointer-events: auto;
+}
+#command-dock
+  #gev-voice-control[data-provider-choice='true']
+  .gev-voice-help-tray,
+#command-dock #gev-voice-control[data-provider-choice='true'] .gev-voice-card,
+#command-dock
+  #gev-voice-control[data-provider-choice='true']
+  .gev-voice-error-tray {
+  bottom: calc(100% + 4.8rem + var(--gev-provider-lift));
+}
+#command-dock.dock-has-pinned-tray
+  #gev-voice-control[data-provider-choice='true'] {
+  --gev-provider-lift: calc(1.7rem + var(--dock-pinned-stack-height));
+}
+/* Pinned trays separate the chooser from its hover owner. Keep it reachable
+   across that gap without requiring keyboard focus to hold it open. */
+#command-dock.dock-has-pinned-tray .gev-voice-provider-field {
+  opacity: 1;
+  pointer-events: auto;
+}
+@media (max-width: 900px) {
+  /* The attribution clearance also creates a gap for mouse users in a
+     narrow window, so the raised chooser must not depend on root hover. */
+  .gev-voice-provider-field {
+    opacity: 1;
+    pointer-events: auto;
+  }
+  #command-dock #gev-voice-control[data-provider-choice='true'] {
+    --gev-provider-lift: 3rem;
+  }
+  #command-dock.dock-has-pinned-tray
+    #gev-voice-control[data-provider-choice='true'] {
+    --gev-provider-lift: calc(3.5rem + var(--dock-pinned-stack-height));
+  }
+}
+@media (max-width: 720px) {
+  #command-dock #gev-voice-control[data-provider-choice='true'] {
+    --gev-provider-lift: calc(2vh + 2.5rem);
+  }
+  #command-dock.dock-has-pinned-tray
+    #gev-voice-control[data-provider-choice='true'] {
+    --gev-provider-lift: calc(2vh + 3rem + var(--dock-pinned-stack-height));
+  }
+}
+@media (hover: none) {
+  .gev-voice-provider-field {
+    opacity: 1;
+    pointer-events: auto;
+  }
+}

src/voice/commands.js

@@ -1,8 +1,16 @@
 import { createVoiceCommands as bindVoiceCommands } from './sessionCommands.js';
 import { createRealtimeSession } from './realtimeSession.js';
+import { createGeminiSession } from './geminiSession.js';
+import { createProviderCommands } from './providerCommands.js';
 
 /** Default composition; callers may supply another session adapter factory. */
-export function createVoiceCommands(options) {
+export function createVoiceCommands(options = {}) {
+  // Generic hosts retain the existing default; standalone opts in explicitly.
+  if (!options.createSession && options.supportedProviders !== undefined)
+    return createProviderCommands(options, {
+      bind: bindVoiceCommands,
+      factories: { openai: createRealtimeSession, gemini: createGeminiSession },
+    });
   return bindVoiceCommands({
     createSession: createRealtimeSession,
     ...options,

src/voice/control.js

@@ -39,6 +39,10 @@ export function createVoiceControl({ reset = false } = {}) {
     root.dataset.status = 'idle';
     root.dataset.speaker = 'idle';
     root.innerHTML = `
+      <label id="gev-voice-provider-field" class="gev-voice-provider-field" hidden>
+        <span>${t('Voice provider')}</span>
+        <select id="gev-voice-provider" aria-label="${t('Voice provider')}" title="${t('Changing provider reconnects voice if it is on.')}"></select>
+      </label>
       <div class="gev-voice-heading">
         <div class="gev-voice-kicker">${t('AI AGENT')}</div>
         <div id="gev-voice-status">${voiceStatusLabel('idle')}</div>
@@ -110,6 +114,8 @@ export function createVoiceControl({ reset = false } = {}) {
   }
   return {
     root,
+    providerField: root.querySelector('#gev-voice-provider-field'),
+    providerSelect: root.querySelector('#gev-voice-provider'),
     button: root.querySelector('#gev-voice-button'),
     buttonLabel: root.querySelector('.gev-mic-label'),
     status: root.querySelector('#gev-voice-status'),

src/voice/geminiAcquisition.test.mjs

@@ -0,0 +1,142 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  harness,
+  deferred,
+  tick,
+} from '../testSupport/geminiNativeHarness.mjs';
+
+function unreadResponse(bytes = null) {
+  const state = { reads: 0, cancelled: 0 };
+  const response = new Response(
+    new ReadableStream(
+      {
+        pull(controller) {
+          state.reads++;
+          if (bytes) controller.enqueue(bytes);
+        },
+        cancel() {
+          state.cancelled++;
+        },
+      },
+      { highWaterMark: 0 },
+    ),
+  );
+  return { response, state };
+}
+
+test('already aborted token request does not acquire or read a response', async (t) => {
+  let fetches = 0;
+  const h = harness({
+    fetchImpl: () => {
+      fetches++;
+      throw Error('must not fetch');
+    },
+  });
+  t.after(() => h.c.stop());
+  const abort = new AbortController();
+  abort.abort();
+  await assert.rejects(h.c.requestToken(abort.signal), { name: 'AbortError' });
+  assert.equal(fetches, 0);
+});
+
+for (const phase of [
+  'before response',
+  'between resolution and continuation',
+]) {
+  test(`aborted token acquisition closes the unread body ${phase}`, async (t) => {
+    const gate = deferred();
+    const h = harness({ fetchImpl: () => gate.promise });
+    t.after(() => h.c.stop());
+    const abort = new AbortController();
+    const { response, state } = unreadResponse();
+    const result = assert.rejects(h.c.requestToken(abort.signal), {
+      name: 'AbortError',
+    });
+    if (phase === 'before response') abort.abort();
+    gate.resolve(response);
+    if (phase !== 'before response') queueMicrotask(() => abort.abort());
+    await result;
+    await tick();
+    assert.deepEqual(state, { reads: 0, cancelled: 1 });
+  });
+}
+
+test('token body cap cancels a native response stream', async (t) => {
+  const { response, state } = unreadResponse(new Uint8Array(256 * 1024 + 1));
+  const h = harness({ fetchImpl: async () => response });
+  t.after(() => h.c.stop());
+  await assert.rejects(
+    h.c.requestToken(new AbortController().signal),
+    /too large|exceed|limit/i,
+  );
+  assert.equal(state.cancelled, 1);
+  assert.equal(state.reads, 1);
+});
+
+test('token body read ends promptly on caller abort and releases the reader', async (t) => {
+  const { response, state } = unreadResponse();
+  const h = harness({ fetchImpl: async () => response });
+  t.after(() => h.c.stop());
+  const abort = new AbortController();
+  const result = assert.rejects(h.c.requestToken(abort.signal), {
+    name: 'AbortError',
+  });
+  await tick();
+  assert.equal(state.reads, 1);
+  abort.abort();
+  await result;
+  assert.equal(state.cancelled, 1);
+  assert.equal(response.body.locked, false);
+});
+
+test('permission grant resolved just before Stop releases its tracks and preserves a fresh start', async (t) => {
+  const gate = deferred();
+  const h = harness({ getUserMedia: () => gate.promise });
+  t.after(() => h.c.stop());
+  const stream = h.makeStream();
+  const start = h.c.start();
+  gate.resolve(stream);
+  queueMicrotask(() => h.c.stop());
+  await start;
+  await tick();
+  assert.equal(h.tracks[0].readyState, 'ended');
+  assert.equal(h.requests.length, 0);
+  assert.equal(h.sockets.length, 0);
+  assert.equal(h.captures[0].closed, true);
+  h.c.getUserMedia = async () => h.makeStream();
+  await h.c.start();
+  assert.equal(h.c.status, 'listening');
+  assert.equal(h.tracks[1].readyState, 'live');
+  assert.equal(h.captures[1].closed, false);
+});
+
+test('late audio initialization cannot connect a retired microphone or close successor audio', async (t) => {
+  const gate = deferred();
+  const h = harness();
+  t.after(() => h.c.stop());
+  const createAudio = h.c.createAudio;
+  let first = true;
+  h.c.createAudio = (options) => {
+    const audio = createAudio(options);
+    if (first) {
+      first = false;
+      audio.initialize = () => gate.promise;
+      audio.connectMicrophone = () =>
+        assert.fail('retired initialization must not connect');
+    }
+    return audio;
+  };
+  const oldStart = h.c.start();
+  await tick();
+  h.c.stop();
+  await h.c.start();
+  gate.resolve();
+  await oldStart;
+  await tick();
+  assert.equal(h.c.status, 'listening');
+  assert.equal(h.captures[0].closed, true);
+  assert.equal(h.captures[1].closed, false);
+  assert.equal(h.tracks[0].readyState, 'ended');
+  assert.equal(h.tracks[1].readyState, 'live');
+});

src/voice/geminiAudio.js

@@ -0,0 +1,380 @@
+import { msg } from '../i18n/marker.js';
+const MAX_AUDIO_BYTES = 2 * 1024 * 1024;
+const MAX_QUEUED_SECONDS = 60;
+const MAX_QUEUED_SOURCES = 256;
+const PTT_WINDOW_SAMPLES = 160; // 10 ms at the worklet's fixed 16 kHz.
+const PTT_ENERGY_FLOOR = 0.002;
+const PTT_PRE_ROLL_BYTES = 16000 * 2 * 0.4;
+
+/** Admit manual input only after sustained energy; not an utterance detector. */
+function pttCapture(captureId) {
+  return {
+    captureId,
+    admitted: false,
+    buffers: [],
+    bytes: 0,
+    samples: 0,
+    energy: 0,
+    aboveFloor: 0,
+    voicedWindows: 0,
+  };
+}
+
+function hasPttEnergy(state, pcm) {
+  for (let index = 0; index + 1 < pcm.byteLength; index += 2) {
+    const sample = pcm.getInt16(index, true) / 32768;
+    state.energy += sample * sample;
+    if (Math.abs(sample) >= PTT_ENERGY_FLOOR) state.aboveFloor++;
+    if (++state.samples !== PTT_WINDOW_SAMPLES) continue;
+    // Requiring occupancy as well as RMS rejects isolated high-peak key clicks.
+    const voiced =
+      state.energy / state.samples >= PTT_ENERGY_FLOOR ** 2 &&
+      state.aboveFloor >= PTT_WINDOW_SAMPLES / 8;
+    state.voicedWindows = voiced ? state.voicedWindows + 1 : 0;
+    state.samples = state.energy = state.aboveFloor = 0;
+    if (state.voicedWindows >= 2) return true;
+  }
+  return false;
+}
+
+export function pcmBytesToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = '';
+  for (let offset = 0; offset < bytes.length; offset += 8192) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  }
+  return btoa(binary);
+}
+
+export function decodeGeminiPcm(data, mimeType = 'audio/pcm;rate=24000') {
+  if (
+    typeof data !== 'string' ||
+    data.length > 4 * Math.ceil(MAX_AUDIO_BYTES / 3)
+  )
+    throw new Error(msg('Gemini returned an oversized audio chunk'));
+  const match = /^audio\/pcm(?:;rate=(\d+))?$/.exec(mimeType);
+  if (!match)
+    throw new Error(msg('Gemini returned an unsupported audio format'));
+  const sampleRate = Number(match[1] || 24000);
+  if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 96000)
+    throw new Error(msg('Gemini returned an invalid audio sample rate'));
+  const binary = atob(data);
+  if (binary.length > MAX_AUDIO_BYTES)
+    throw new Error(msg('Gemini returned an oversized audio chunk'));
+  if (!binary.length || binary.length % 2)
+    throw new Error(msg('Gemini returned incomplete PCM audio'));
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++)
+    bytes[index] = binary.charCodeAt(index);
+  const view = new DataView(bytes.buffer);
+  const samples = new Float32Array(bytes.length / 2);
+  for (let index = 0; index < samples.length; index++)
+    samples[index] = view.getInt16(index * 2, true) / 32768;
+  return { samples, sampleRate };
+}
+
+/** Own capture and playback independently from the Live protocol. */
+export function createGeminiAudio({
+  pushToTalk = false,
+  onAudioStart,
+  onAudio,
+  onAudioEnd,
+  onAudioDiscard,
+  onDrain,
+  onError,
+  AudioContextClass = globalThis.AudioContext || globalThis.webkitAudioContext,
+  AudioWorkletNodeClass = globalThis.AudioWorkletNode,
+} = {}) {
+  if (!AudioContextClass || !AudioWorkletNodeClass)
+    throw new Error(
+      msg('This browser does not support Gemini microphone audio'),
+    );
+  let captureContext;
+  let playbackContext;
+  let output;
+  let meter;
+  let resumed;
+  const closeContext = (context) => {
+    try {
+      return Promise.resolve(context?.close());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+  try {
+    // Capture at the device rate; the worklet explicitly resamples to 16 kHz.
+    captureContext = new AudioContextClass();
+    playbackContext = new AudioContextClass({ sampleRate: 24000 });
+    // Resume both synchronously within the mic gesture, before any awaits.
+    const resume = (context) => {
+      try {
+        return Promise.resolve(context.resume());
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    };
+    resumed = Promise.all([resume(captureContext), resume(playbackContext)]);
+    // Permission may remain pending before initialize observes this failure.
+    void resumed.catch(() => {});
+    output = playbackContext.createGain();
+    meter = playbackContext.createMediaStreamDestination();
+    output.connect(playbackContext.destination);
+    output.connect(meter);
+  } catch (error) {
+    output?.disconnect();
+    meter?.disconnect();
+    meter?.stream.getTracks?.().forEach((track) => track.stop());
+    void Promise.allSettled([
+      closeContext(captureContext),
+      closeContext(playbackContext),
+    ]);
+    throw error;
+  }
+  let closed = false;
+  let closeResult;
+  let capture = null;
+  let microphone = null;
+  let mute = null;
+  let nextTime = 0;
+  let inputChunks = 0;
+  let inputPeak = 0;
+  let nonSilentInputChunks = 0;
+  let outputChunks = 0;
+  let outputSamples = 0;
+  let completedOutputSamples = 0;
+  let discardedOutputSamples = 0;
+  let pendingPtt = null;
+  let latestPttCaptureId = 0;
+  let suppressedPttCaptures = 0;
+  let admittedPttCaptures = 0;
+  const sources = new Map();
+
+  const emitAudio = (buffer, metadata) =>
+    onAudio?.(
+      { data: pcmBytesToBase64(buffer), mimeType: 'audio/pcm;rate=16000' },
+      metadata,
+    );
+
+  function clearPlayback() {
+    const oldSources = [...sources];
+    sources.clear();
+    nextTime = playbackContext.currentTime;
+    for (const [source, sampleCount] of oldSources) {
+      discardedOutputSamples += sampleCount;
+      source.onended = null;
+      try {
+        source.stop();
+      } catch {
+        /* Already ended. */
+      }
+      source.disconnect();
+    }
+  }
+
+  return {
+    outputStream: meter.stream,
+    get pending() {
+      return sources.size > 0;
+    },
+    async initialize(signal) {
+      try {
+        await Promise.all([
+          resumed,
+          captureContext.audioWorklet.addModule(
+            new URL('./geminiCaptureWorklet.js', import.meta.url),
+          ),
+        ]);
+        signal?.throwIfAborted();
+        if (closed) throw new DOMException('Voice stopped', 'AbortError');
+      } catch (error) {
+        await this.close();
+        throw error;
+      }
+    },
+    connectMicrophone(stream, enabled, metadata) {
+      if (closed) throw new DOMException('Voice stopped', 'AbortError');
+      capture = new AudioWorkletNodeClass(
+        captureContext,
+        'gev-gemini-capture',
+        {
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          outputChannelCount: [1],
+        },
+      );
+      capture.port.onmessage = ({ data }) => {
+        if (closed) return;
+        // Capture ownership is transport metadata, never part of Live audio.
+        if (!Number.isSafeInteger(data?.captureId) || data.captureId <= 0)
+          return;
+        const metadata = { captureId: data.captureId };
+        try {
+          if (data?.type === 'audio' && data.buffer instanceof ArrayBuffer) {
+            inputChunks++;
+            const pcm = new DataView(data.buffer);
+            let peak = 0;
+            for (let index = 0; index + 1 < pcm.byteLength; index += 2)
+              peak = Math.max(
+                peak,
+                Math.abs(pcm.getInt16(index, true)) / 32768,
+              );
+            inputPeak = Math.max(inputPeak, peak);
+            if (peak >= 0.01) nonSilentInputChunks++;
+            if (!pushToTalk) emitAudio(data.buffer, metadata);
+            else {
+              const state = pendingPtt;
+              if (state?.captureId !== data.captureId) return;
+              if (state.admitted) emitAudio(data.buffer, metadata);
+              else {
+                state.buffers.push(data.buffer);
+                state.bytes += data.buffer.byteLength;
+                if (hasPttEnergy(state, pcm)) {
+                  state.admitted = true;
+                  admittedPttCaptures++;
+                  // Context and activityStart are gated together with PCM.
+                  onAudioStart?.(metadata);
+                  for (const buffer of state.buffers) {
+                    if (closed || pendingPtt !== state) break;
+                    emitAudio(buffer, metadata);
+                  }
+                  state.buffers = [];
+                  state.bytes = 0;
+                } else {
+                  while (state.bytes > PTT_PRE_ROLL_BYTES) {
+                    state.bytes -= state.buffers.shift().byteLength;
+                  }
+                }
+              }
+            }
+          } else if (data?.type === 'start') {
+            if (!pushToTalk) onAudioStart?.(metadata);
+            else if (data.captureId > latestPttCaptureId) {
+              latestPttCaptureId = data.captureId;
+              pendingPtt = pttCapture(data.captureId);
+            }
+          } else if (data?.type === 'end') {
+            if (!pushToTalk) onAudioEnd?.(metadata);
+            else if (pendingPtt?.captureId === data.captureId) {
+              const admitted = pendingPtt.admitted;
+              pendingPtt = null;
+              if (admitted) onAudioEnd?.(metadata);
+              else {
+                suppressedPttCaptures++;
+                onAudioDiscard?.(metadata);
+              }
+            }
+          }
+        } catch (error) {
+          onError?.(error);
+        }
+      };
+      capture.onprocessorerror = () => {
+        if (!closed)
+          onError?.(new Error(msg('Microphone audio processing failed')));
+      };
+      microphone = captureContext.createMediaStreamSource(stream);
+      mute = captureContext.createGain();
+      mute.gain.value = 0;
+      capture.port.postMessage({
+        enabled: Boolean(enabled),
+        captureId: metadata?.captureId,
+      });
+      microphone.connect(capture);
+      capture.connect(mute);
+      mute.connect(captureContext.destination);
+    },
+    setMicrophoneEnabled(enabled, metadata) {
+      if (closed) return;
+      capture?.port.postMessage({
+        enabled: Boolean(enabled),
+        captureId: metadata?.captureId,
+      });
+    },
+    play(data, mimeType) {
+      if (closed) return;
+      // Tiny chunks can exhaust source nodes long before the duration limit.
+      if (sources.size >= MAX_QUEUED_SOURCES)
+        throw new Error(
+          msg('Gemini audio playback fell behind. Reconnect to continue.'),
+        );
+      const { samples, sampleRate } = decodeGeminiPcm(data, mimeType);
+      const start = Math.max(playbackContext.currentTime + 0.02, nextTime);
+      if (
+        start + samples.length / sampleRate - playbackContext.currentTime >
+        MAX_QUEUED_SECONDS
+      )
+        throw new Error(
+          msg('Gemini audio playback fell behind. Reconnect to continue.'),
+        );
+      const buffer = playbackContext.createBuffer(
+        1,
+        samples.length,
+        sampleRate,
+      );
+      buffer.copyToChannel(samples, 0);
+      const source = playbackContext.createBufferSource();
+      source.buffer = buffer;
+      source.connect(output);
+      sources.set(source, samples.length);
+      source.onended = () => {
+        if (!sources.delete(source)) return;
+        completedOutputSamples += samples.length;
+        source.disconnect();
+        if (!closed && !sources.size) onDrain?.();
+      };
+      nextTime = start + buffer.duration;
+      outputChunks++;
+      outputSamples += samples.length;
+      source.start(start);
+    },
+    clearPlayback,
+    diagnostics() {
+      return {
+        inputChunks,
+        inputPeak,
+        nonSilentInputChunks,
+        outputChunks,
+        outputSamples,
+        completedOutputSamples,
+        discardedOutputSamples,
+        queuedSeconds: Math.max(0, nextTime - playbackContext.currentTime),
+        contextState:
+          captureContext.state === playbackContext.state
+            ? captureContext.state
+            : 'suspended',
+        captureContextState: captureContext.state,
+        playbackContextState: playbackContext.state,
+        captureSampleRate: captureContext.sampleRate,
+        playbackSampleRate: playbackContext.sampleRate,
+        inputSampleRate: 16000,
+        suppressedPttCaptures,
+        admittedPttCaptures,
+        pttBufferedBytes: pendingPtt?.bytes || 0,
+      };
+    },
+    close() {
+      if (closed) return closeResult;
+      closed = true;
+      pendingPtt = null;
+      clearPlayback();
+      if (capture) {
+        capture.port.onmessage = null;
+        capture.onprocessorerror = null;
+        capture.port.close();
+        capture.disconnect();
+      }
+      microphone?.disconnect();
+      mute?.disconnect();
+      output.disconnect();
+      meter.disconnect();
+      meter.stream.getTracks?.().forEach((track) => track.stop());
+      closeResult = Promise.allSettled([
+        closeContext(captureContext),
+        closeContext(playbackContext),
+      ]).then((results) =>
+        results.every((result) => result.status === 'fulfilled'),
+      );
+      return closeResult;
+    },
+  };
+}

src/voice/geminiAutomaticVad.test.mjs

@@ -0,0 +1,791 @@
+// Native automatic activity, reply ownership and expiry lifecycle regressions.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  harness,
+  tick,
+  deferred,
+} from '../testSupport/geminiNativeHarness.mjs';
+const vad = (ws, type) => ws.message({ voiceActivity: { type } });
+const onset = (ws) => {
+  vad(ws, 'ACTIVITY_START');
+  vad(ws, 'ACTIVITY_END');
+};
+const split = (ws) => {
+  onset(ws);
+  onset(ws);
+};
+const audio = {
+  serverContent: {
+    modelTurn: {
+      parts: [
+        { inlineData: { data: 'AAAA', mimeType: 'audio/pcm;rate=24000' } },
+      ],
+    },
+  },
+};
+const done = (ws) => ws.message({ serverContent: { turnComplete: true } });
+const tools = (ws, id) =>
+  ws.message({
+    toolCall: {
+      functionCalls: [
+        {
+          id,
+          name: 'adjust_camera_zoom',
+          args: { direction: 'out', amount: 'little' },
+        },
+      ],
+    },
+  });
+const responses = (ws) =>
+  ws.sent.flatMap((m) => m.toolResponse?.functionResponses || []);
+function close(h) {
+  h.c.stop();
+  assert.equal(h.timers.size, 0, 'owned timers released');
+}
+test('N1 VAD-only split admits the first real answer and completes after playback', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    split(ws);
+    ws.message(audio);
+    ws.message({ serverContent: { outputTranscription: { text: 'Answer' } } });
+    done(ws);
+    assert.equal(h.captures[0].played.length, 1);
+    h.captures[0].drain();
+    assert.equal(
+      h.events.findLast((e) => e.type === 'completion')?.status,
+      'completed',
+    );
+    assert.equal(h.c.retiredReplyPending, false);
+  } finally {
+    close(h);
+  }
+});
+test('N2 VAD-only split does not arm a nonexistent reply timeout', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    split(h.sockets[0]);
+    h.advance(5001);
+    assert.equal(h.c.status, 'listening');
+    assert.equal(h.c.retiredReplyPending, false);
+    assert.equal(h.c.retiredBoundaryWait, null);
+  } finally {
+    close(h);
+  }
+});
+test('N3 server interruption before output still fences until ordered turnComplete', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    split(ws);
+    ws.message({ serverContent: { interrupted: true } });
+    assert.equal(h.c.retiredReplyPending, true);
+    ws.message(audio);
+    tools(ws, 'retired-before-boundary');
+    await h.c.toolQueue;
+    assert.equal(h.captures[0].played.length, 0);
+    assert.equal(h.calls.length, 0);
+    assert.equal(responses(ws).length, 0);
+    ws.message({
+      serverContent: { ...audio.serverContent, turnComplete: true },
+    });
+    assert.equal(
+      h.captures[0].played.length,
+      0,
+      'coalesced retired content is discarded',
+    );
+    ws.message(audio);
+    assert.equal(h.captures[0].played.length, 1);
+    done(ws);
+    h.captures[0].drain();
+    assert.equal(
+      h.events.findLast((e) => e.type === 'completion')?.status,
+      'completed',
+    );
+  } finally {
+    close(h);
+  }
+});
+test('N4 generationComplete is server evidence and next onset retires it', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message({ serverContent: { generationComplete: true } });
+    onset(ws);
+    assert.equal(h.c.retiredReplyPending, true);
+    assert.ok(h.c.retiredBoundaryWait);
+    ws.message(audio);
+    tools(ws, 'old-generation');
+    await h.c.toolQueue;
+    assert.equal(h.captures[0].played.length, 0);
+    assert.equal(h.calls.length, 0);
+    done(ws);
+    assert.equal(h.c.retiredReplyPending, false);
+  } finally {
+    close(h);
+  }
+});
+test('N5 goAway during VAD-only activity waits for actual reply and playback', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    split(ws);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+    assert.ok(h.c.goAway);
+    assert.equal(ws.closed, undefined);
+    h.advance(5001);
+    assert.equal(h.c.isActive(), true);
+    ws.message(audio);
+    done(ws);
+    assert.equal(
+      h.c.isActive(),
+      true,
+      'pending actual PCM drains before expiry',
+    );
+    h.captures[0].drain();
+    assert.equal(h.c.status, 'error');
+    assert.equal(ws.closed, true);
+  } finally {
+    close(h);
+  }
+});
+test('N6 first server tool after VAD-only split executes exactly once', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    split(ws);
+    tools(ws, 'new-generation');
+    await h.c.toolQueue;
+    assert.equal(h.calls.length, 1);
+    assert.equal(
+      responses(ws).filter((x) => x.id === 'new-generation').length,
+      1,
+    );
+    assert.equal(responses(ws).at(-1).response.ok, true);
+    tools(ws, 'new-generation');
+    await h.c.toolQueue;
+    assert.equal(h.calls.length, 1);
+    assert.equal(
+      responses(ws).filter((x) => x.id === 'new-generation').length,
+      1,
+    );
+  } finally {
+    close(h);
+  }
+});
+test('C1 actual old audio followed by onset fences late audio and tool until boundary', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    ws.message(audio);
+    onset(ws);
+    assert.equal(h.c.retiredReplyPending, true);
+    ws.message(audio);
+    tools(ws, 'late-old');
+    await h.c.toolQueue;
+    assert.equal(h.captures[0].played.length, 1);
+    assert.equal(h.calls.length, 0);
+    ws.message({ serverContent: { interrupted: true } });
+    ws.message(audio);
+    assert.equal(h.captures[0].played.length, 1);
+    done(ws);
+    ws.message(audio);
+    assert.equal(h.captures[0].played.length, 2);
+  } finally {
+    close(h);
+  }
+});
+test('C2 first server tool in flight is aborted and never answered after new onset', async () => {
+  const gate = deferred(),
+    entered = [];
+  const h = harness({
+    runAction: async (_n, _a, o) => {
+      entered.push(o);
+      await gate.promise;
+      return { ok: true };
+    },
+  });
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    tools(ws, 'old-running');
+    await tick();
+    assert.equal(entered.length, 1);
+    onset(ws);
+    assert.equal(entered[0].signal.aborted, true);
+    gate.resolve();
+    await h.c.toolQueue;
+    assert.equal(responses(ws).filter((x) => x.id === 'old-running').length, 0);
+    assert.equal(h.c.retiredReplyPending, true);
+  } finally {
+    gate.resolve();
+    close(h);
+  }
+});
+test('C5 typed request before first server output still retires on next onset', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    assert.equal(h.c.sendTextCommand('Zoom in'), true);
+    onset(ws);
+    assert.equal(h.c.retiredReplyPending, true);
+    ws.message(audio);
+    tools(ws, 'late-typed');
+    await h.c.toolQueue;
+    assert.equal(h.captures[0].played.length, 0);
+    assert.equal(h.calls.length, 0);
+  } finally {
+    close(h);
+  }
+});
+test('N7 old retired boundary preserves the newer automatic owner for goAway', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    const oldOwner = h.c.automaticActivityOwner;
+    ws.message(audio);
+    onset(ws);
+    const successor = h.c.automaticActivityOwner;
+    assert.notEqual(successor, oldOwner);
+    assert.equal(h.c.retiredAutomaticActivityOwner, oldOwner);
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    assert.equal(h.c.automaticActivityOwner, successor);
+    assert.equal(h.c.automaticTurnOpen, true);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+    ws.message(audio);
+    done(ws);
+    h.captures[0].drain();
+    assert.equal(h.c.status, 'error');
+  } finally {
+    close(h);
+  }
+});
+test('N8 old automatic owner with no successor is cleared by its retired boundary', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    const owner = h.c.automaticActivityOwner;
+    ws.message(audio);
+    ws.message({ serverContent: { interrupted: true } });
+    assert.equal(h.c.retiredAutomaticActivityOwner, owner);
+    done(ws);
+    assert.equal(h.c.automaticTurnOpen, false);
+    assert.equal(h.c.automaticActivityOwner, null);
+    assert.equal(h.c.retiredAutomaticActivityOwner, null);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), false, 'no invented successor wait');
+  } finally {
+    close(h);
+  }
+});
+test('N9 coalesced old completion and new VAD preserves the new owner', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message(audio);
+    vad(ws, 'ACTIVITY_END');
+    ws.message({
+      voiceActivity: { type: 'ACTIVITY_START' },
+      serverContent: { interrupted: true, turnComplete: true },
+    });
+    assert.equal(h.c.automaticTurnOpen, true);
+    assert.ok(h.c.automaticActivityOwner);
+    assert.equal(h.c.retiredAutomaticActivityOwner, null);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+  } finally {
+    close(h);
+  }
+});
+test('N10 stop, restart and destroy release automatic owner identities and timers', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    onset(h.sockets[0]);
+    const first = h.c.automaticActivityOwner;
+    h.c.stop();
+    assert.equal(h.c.automaticTurnOpen, false);
+    assert.equal(h.c.automaticActivityOwner, null);
+    assert.equal(h.c.retiredAutomaticActivityOwner, null);
+    assert.equal(h.c.automaticActivitySequence, 0);
+    await h.c.start();
+    onset(h.sockets[1]);
+    assert.notEqual(h.c.automaticActivityOwner, first);
+    assert.notEqual(h.c.automaticActivityOwner.epoch, first.epoch);
+    h.c.stop({ removeUi: true });
+    assert.equal(h.c.disposed, true);
+    assert.equal(h.c.automaticTurnOpen, false);
+    assert.equal(h.c.automaticActivityOwner, null);
+    assert.equal(h.c.retiredAutomaticActivityOwner, null);
+    assert.equal(h.timers.size, 0);
+  } finally {
+    close(h);
+  }
+});
+test('N11 deferred typed ownership counts discarded open-mic PCM without queuing or replay', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    ws.message(audio);
+    assert.equal(h.c.sendTextCommand('Zoom in'), true);
+    assert.equal(h.c.sendTextCommand('Zoom out'), true);
+    assert.equal(h.c.deferredInput.kind, 'user-text');
+    const before = ws.sent.filter((x) => x.realtimeInput?.audio).length;
+    const metadata = { captureId: h.c.captureOwner.captureId };
+    h.captures[0].callbacks.onAudio(
+      { data: 'AAAA', mimeType: 'audio/pcm;rate=16000' },
+      metadata,
+    );
+    assert.equal(ws.sent.filter((x) => x.realtimeInput?.audio).length, before);
+    assert.equal(
+      h.c.deferredInput.messages.some((x) => x.realtimeInput?.audio),
+      false,
+    );
+    assert.equal(h.c.getDiagnostics().droppedAudioChunks, 1);
+    assert.deepEqual(h.c.getDiagnostics().deferredAudioDrops, {
+      nonPttOwner: 1,
+      closedActivity: 0,
+    });
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    done(ws);
+    assert.equal(
+      ws.sent.filter((x) => x.realtimeInput?.audio).length,
+      before,
+      'no wrong-owner PCM replay after boundaries',
+    );
+  } finally {
+    close(h);
+  }
+});
+test('N12 goAway before old completion still waits for the newer automatic owner', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message(audio);
+    onset(ws);
+    const successor = h.c.automaticActivityOwner;
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    assert.equal(h.c.automaticActivityOwner, successor);
+    assert.equal(
+      h.c.isActive(),
+      true,
+      'old boundary during goAway cannot end successor wait',
+    );
+    ws.message(audio);
+    done(ws);
+    h.captures[0].drain();
+    assert.equal(h.c.status, 'error');
+  } finally {
+    close(h);
+  }
+});
+for (const interruptedBeforeExpiry of [false, true])
+  test(`N13 no successor clears retired ownership with goAway ${interruptedBeforeExpiry ? 'after interruption' : 'before interruption'}`, async () => {
+    const h = harness();
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      onset(ws);
+      ws.message(audio);
+      if (interruptedBeforeExpiry)
+        ws.message({ serverContent: { interrupted: true } });
+      ws.message({ goAway: { timeLeft: '30s' } });
+      assert.equal(h.c.isActive(), true);
+      ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+      assert.equal(h.c.automaticTurnOpen, false);
+      assert.equal(h.c.automaticActivityOwner, null);
+      assert.equal(
+        h.c.isActive(),
+        false,
+        'no successor finishes at its actual boundary',
+      );
+    } finally {
+      close(h);
+    }
+  });
+test('N14 native interruption during goAway aborts pending old tool and suppresses late response', async () => {
+  const gate = deferred(),
+    entered = [];
+  const h = harness({
+    runAction: async (_n, _a, o) => {
+      entered.push(o);
+      await gate.promise;
+      return { ok: true };
+    },
+  });
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    tools(ws, 'expiring-old-tool');
+    await tick();
+    assert.equal(entered.length, 1);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    assert.equal(entered[0].signal.aborted, true);
+    gate.resolve();
+    await h.c.toolQueue;
+    assert.equal(
+      responses(ws).filter((x) => x.id === 'expiring-old-tool').length,
+      0,
+    );
+    assert.equal(h.c.isActive(), false);
+  } finally {
+    gate.resolve();
+    close(h);
+  }
+});
+test('N15 goAway still refuses local PTT and typed replacement without reopening microphone', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message(audio);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    const turn = h.c.turn,
+      sent = ws.sent.length;
+    assert.equal(h.c.bargeIn(), false);
+    assert.equal(h.c.sendTextCommand('Zoom out'), false);
+    h.c.interrupt('push-to-talk');
+    assert.equal(h.c.turn, turn);
+    assert.equal(ws.sent.length, sent);
+    assert.equal(
+      h.tracks.every((t) => !t.enabled),
+      true,
+    );
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    assert.equal(h.c.isActive(), false);
+    assert.equal(
+      h.tracks.every((t) => t.readyState === 'ended'),
+      true,
+    );
+  } finally {
+    close(h);
+  }
+});
+
+test('T-F1a PTT successor PCM survives retired boundary and a second input fences its late output', async () => {
+  const h = harness();
+  try {
+    await h.c.start({ pushToTalk: true });
+    const ws = h.sockets[0],
+      a = h.captures[0];
+    ws.message(audio);
+    h.c.input.pushToTalkKeyHeld = true;
+    assert.equal(h.c.input.bargeIn(), true);
+    h.c.input.setMicrophoneEnabled(true);
+    a.callbacks.onAudio(
+      { data: 'AAAB', mimeType: 'audio/pcm;rate=16000' },
+      a.metadata,
+    );
+    h.c.input.setMicrophoneEnabled(false);
+    assert.equal(h.c.replyPending, true);
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    assert.equal(
+      h.c.replyPending,
+      true,
+      'old boundary cannot clear submitted successor',
+    );
+    assert.equal(h.c.sendTextCommand('Zoom out second request'), true);
+    assert.ok(h.c.currentTypedInput());
+    const played = a.played.length;
+    ws.message(audio);
+    tools(ws, 'late-ptt-predecessor');
+    await h.c.toolQueue;
+    assert.equal(a.played.length, played);
+    assert.equal(
+      h.calls.length,
+      0,
+      'no old tool under newer local typed input',
+    );
+    done(ws);
+    tools(ws, 'current-typed');
+    await h.c.toolQueue;
+    assert.equal(h.calls.length, 1);
+    assert.equal(h.calls[0].options.userTurn, undefined);
+    assert.equal(h.calls[0].options.isCurrent(), true);
+    assert.equal(h.c.currentTypedInput().text, 'Zoom out second request');
+  } finally {
+    close(h);
+  }
+});
+for (const expiryBeforeBoundary of [false, true])
+  test(`T-F1b VAD then submitted text survives goAway ${expiryBeforeBoundary ? 'before' : 'after'} retired boundary`, async () => {
+    const h = harness();
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      ws.message(audio);
+      onset(ws);
+      assert.equal(h.c.sendTextCommand('Zoom out successor'), true);
+      const typed = h.c.currentTypedInput();
+      assert.ok(typed);
+      assert.equal(h.c.replyPending, true);
+      if (expiryBeforeBoundary) ws.message({ goAway: { timeLeft: '30s' } });
+      ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+      assert.equal(h.c.replyPending, true);
+      if (!expiryBeforeBoundary) ws.message({ goAway: { timeLeft: '30s' } });
+      assert.equal(h.c.isActive(), true, 'submitted text must finish');
+      tools(ws, 'valid-successor');
+      await h.c.toolQueue;
+      assert.equal(h.calls.length, 1);
+      assert.equal(h.calls[0].options.userTurn, undefined);
+      assert.equal(h.calls[0].options.isCurrent(), true);
+      assert.equal(h.c.currentTypedInput(), typed);
+      ws.message(audio);
+      done(ws);
+      assert.equal(h.c.isActive(), true);
+      h.captures[0].drain();
+      assert.equal(h.c.isActive(), false);
+    } finally {
+      close(h);
+    }
+  });
+for (const repeat of [false, true])
+  test(`T-F2 forwarded A superseded by deferred B cannot run after goAway${repeat ? ' shortened twice' : ''}`, async () => {
+    const h = harness();
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      ws.message(audio);
+      assert.equal(h.c.sendTextCommand('Zoom out A'), true);
+      assert.equal(h.c.replyPending, true);
+      assert.equal(h.c.sendTextCommand('Zoom out B'), true);
+      assert.equal(h.c.deferredInput.kind, 'user-text');
+      assert.ok(h.c.currentTypedInput());
+      onset(ws);
+      assert.equal(h.c.automaticTurnOpen, true);
+      ws.message({ goAway: { timeLeft: '30s' } });
+      assert.equal(h.c.deferredInput, null);
+      if (repeat) {
+        ws.message({ goAway: { timeLeft: '20s' } });
+        ws.message({ goAway: { timeLeft: '10s' } });
+      }
+      assert.equal(h.c.goAway.supersededSuccessor, true);
+      assert.equal(h.c.isActive(), true);
+      ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+      tools(ws, 'superseded-A');
+      await h.c.toolQueue;
+      assert.equal(h.calls.length, 0, 'A cannot run with dropped B authority');
+      assert.equal(
+        h.c.isActive(),
+        false,
+        'ordered boundary closes superseded forwarded predecessor',
+      );
+    } finally {
+      close(h);
+    }
+  });
+test('T-F3 VAD-only no-generation expiry waits to bounded native deadline and releases resources', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    onset(h.sockets[0]);
+    h.sockets[0].message({ goAway: { timeLeft: '30s' } });
+    h.advance(29999);
+    assert.equal(h.c.isActive(), true);
+    h.advance(1);
+    assert.equal(h.c.isActive(), false);
+    assert.equal(h.timers.size, 0);
+    assert.equal(
+      h.tracks.every((t) => t.readyState === 'ended'),
+      true,
+    );
+  } finally {
+    close(h);
+  }
+});
+test('T-C1 coalesced new START and natural old completion preserve newer automatic activity', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message(audio);
+    ws.message({
+      voiceActivity: { type: 'ACTIVITY_START' },
+      serverContent: { turnComplete: true },
+    });
+    assert.equal(h.c.retiredReplyPending, false);
+    assert.equal(h.c.automaticTurnOpen, true);
+    ws.message({ goAway: { timeLeft: '30s' } });
+    assert.equal(h.c.isActive(), true);
+  } finally {
+    close(h);
+  }
+});
+test('T-C2 generationComplete alone followed by natural completion emits completion with no retirement timer', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message({ serverContent: { generationComplete: true } });
+    assert.equal(h.c.replyPending, true);
+    done(ws);
+    assert.equal(
+      h.events.findLast((e) => e.type === 'completion')?.status,
+      'completed',
+    );
+    assert.equal(h.c.replyPending, false);
+    assert.equal(h.c.automaticTurnOpen, false);
+    assert.equal(h.c.retiredBoundaryWait, null);
+    assert.equal(h.timers.size, 0);
+  } finally {
+    close(h);
+  }
+});
+
+test('T-C3 silent PTT terminal completion emits spoken false without fabricated audio', async () => {
+  const h = harness();
+  try {
+    await h.c.start({ pushToTalk: true });
+    const ws = h.sockets[0],
+      a = h.captures[0];
+    h.c.input.setMicrophoneEnabled(true);
+    a.callbacks.onAudio(
+      { data: 'AAAB', mimeType: 'audio/pcm;rate=16000' },
+      a.metadata,
+    );
+    h.c.input.setMicrophoneEnabled(false);
+    assert.equal(h.c.userTurnPending, true);
+    ws.message({ serverContent: { generationComplete: true } });
+    done(ws);
+    const event = h.events.findLast((e) => e.type === 'completion');
+    assert.equal(event.status, 'completed');
+    assert.equal(event.spoken, false);
+    assert.equal(a.played.length, 0);
+    assert.equal(h.c.userTurnPending, false);
+  } finally {
+    close(h);
+  }
+});
+test('T-C4 silent terminal boundary waits for pending tool and native follow-up completion', async () => {
+  const gate = deferred(),
+    entered = [];
+  const h = harness({
+    runAction: async (_n, _a, o) => {
+      entered.push(o);
+      await gate.promise;
+      return { ok: true };
+    },
+  });
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    tools(ws, 'pending-terminal-tool');
+    await tick();
+    assert.equal(entered.length, 1);
+    done(ws);
+    assert.equal(
+      h.events.some((e) => e.type === 'completion'),
+      false,
+    );
+    assert.equal(h.c.userTurnPending, false);
+    gate.resolve();
+    await h.c.toolQueue;
+    h.c.finishPlayback();
+    assert.equal(
+      h.events.some((e) => e.type === 'completion'),
+      false,
+    );
+    assert.equal(h.c.replyPending, true, 'tool result awaits native follow-up');
+    done(ws);
+    assert.equal(
+      h.events.findLast((e) => e.type === 'completion')?.status,
+      'completed',
+    );
+  } finally {
+    gate.resolve();
+    close(h);
+  }
+});
+test('T-C5 terminal boundary with queued PCM waits for drain and preserves real spoken state', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    ws.message(audio);
+    ws.message({ serverContent: { generationComplete: true } });
+    done(ws);
+    assert.equal(
+      h.events.some((e) => e.type === 'completion'),
+      false,
+    );
+    h.captures[0].drain();
+    const event = h.events.findLast((e) => e.type === 'completion');
+    assert.equal(event.status, 'completed');
+    assert.equal(event.spoken, true);
+  } finally {
+    close(h);
+  }
+});
+test('T-C6 old retired terminal boundary cannot clear successor userTurnPending', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    ws.message(audio);
+    assert.equal(h.c.sendTextCommand('Zoom out successor'), true);
+    assert.equal(h.c.userTurnPending, true);
+    done(ws);
+    assert.equal(h.c.userTurnPending, true);
+    assert.equal(
+      h.events.some((e) => e.type === 'completion'),
+      false,
+    );
+  } finally {
+    close(h);
+  }
+});
+test('T-C7 reentrant silent completion observer keeps new input pending', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    const emit = h.c.emit.bind(h.c);
+    h.c.emit = (event) => {
+      emit(event);
+      if (event.type === 'completion')
+        h.c.sendTextCommand('Zoom out reentrant');
+    };
+    onset(ws);
+    ws.message({ serverContent: { generationComplete: true } });
+    done(ws);
+    assert.equal(h.events.filter((e) => e.type === 'completion').length, 1);
+    assert.equal(h.c.replyPending, true);
+    assert.equal(h.c.userTurnPending, true);
+    assert.ok(h.c.currentTypedInput());
+    assert.equal(h.c.modelComplete, false);
+  } finally {
+    close(h);
+  }
+});

src/voice/geminiCaptureWorklet.js

@@ -0,0 +1,125 @@
+const OUTPUT_RATE = 16000;
+const FILTER_TAPS = 64;
+const FILTER_PHASES = 128;
+
+// A causal, windowed-sinc low-pass filter avoids folding device frequencies
+// above 8 kHz into speech. Precompute phases; process allocates no filter data.
+function resamplingFilters(inputRate) {
+  const cutoff = 0.45 * Math.min(1, OUTPUT_RATE / inputRate);
+  const filters = new Float32Array(FILTER_TAPS * FILTER_PHASES);
+  for (let phase = 0; phase < FILTER_PHASES; phase++) {
+    let total = 0;
+    for (let tap = 0; tap < FILTER_TAPS; tap++) {
+      const distance = tap - (FILTER_TAPS - 1) / 2 - phase / FILTER_PHASES;
+      const sinc =
+        distance === 0
+          ? 2 * cutoff
+          : Math.sin(2 * Math.PI * cutoff * distance) / (Math.PI * distance);
+      const window =
+        0.5 - 0.5 * Math.cos((2 * Math.PI * tap) / (FILTER_TAPS - 1));
+      const weight = sinc * window;
+      filters[phase * FILTER_TAPS + tap] = weight;
+      total += weight;
+    }
+    for (let tap = 0; tap < FILTER_TAPS; tap++)
+      filters[phase * FILTER_TAPS + tap] /= total;
+  }
+  return filters;
+}
+
+/** PCM microphone capture. Only explicitly enabled frames leave this processor. */
+class GeminiCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.enabled = false;
+    this.captureId = null;
+    this.samples = new Int16Array(1024);
+    this.length = 0;
+    this.inputRate = sampleRate;
+    this.filters =
+      this.inputRate === OUTPUT_RATE ? null : resamplingFilters(this.inputRate);
+    this.history = new Float32Array(FILTER_TAPS);
+    this.resetResampler();
+    this.port.onmessage = ({ data }) => {
+      if (data?.enabled === true) {
+        if (
+          this.enabled ||
+          !Number.isSafeInteger(data.captureId) ||
+          data.captureId <= 0
+        )
+          return;
+        this.captureId = data.captureId;
+        this.resetResampler();
+        this.enabled = true;
+        this.port.postMessage({ type: 'start', captureId: this.captureId });
+      } else if (
+        data?.enabled === false &&
+        this.enabled &&
+        data.captureId === this.captureId
+      ) {
+        this.flush();
+        this.port.postMessage({ type: 'end', captureId: this.captureId });
+        this.enabled = false;
+        this.captureId = null;
+        this.length = 0;
+        // Do not drain filter tails into a later physical microphone capture.
+        this.resetResampler();
+      }
+    };
+  }
+  resetResampler() {
+    this.phase = 0;
+    this.historyIndex = 0;
+    this.history.fill(0);
+  }
+  appendSample(sample) {
+    const value = Math.max(-1, Math.min(1, sample));
+    this.samples[this.length++] = Math.round(
+      value * (value < 0 ? 32768 : 32767),
+    );
+    if (this.length === this.samples.length) this.flush();
+  }
+  flush() {
+    if (!this.length) return;
+    const buffer = new ArrayBuffer(this.length * 2);
+    const view = new DataView(buffer);
+    for (let i = 0; i < this.length; i++)
+      view.setInt16(i * 2, this.samples[i], true);
+    this.port.postMessage(
+      { type: 'audio', buffer, captureId: this.captureId },
+      [buffer],
+    );
+    this.length = 0;
+  }
+  process(inputs) {
+    if (!this.enabled) return true;
+    const channel = inputs[0]?.[0];
+    if (!channel) return true;
+    for (const sample of channel) {
+      if (!this.filters) {
+        this.appendSample(sample);
+        continue;
+      }
+      this.history[this.historyIndex] = sample;
+      this.historyIndex = (this.historyIndex + 1) % FILTER_TAPS;
+      this.phase += OUTPUT_RATE;
+      while (this.phase >= this.inputRate) {
+        this.phase -= this.inputRate;
+        const phase = Math.min(
+          FILTER_PHASES - 1,
+          Math.floor((this.phase * FILTER_PHASES) / OUTPUT_RATE),
+        );
+        let value = 0;
+        for (let tap = 0; tap < FILTER_TAPS; tap++) {
+          const index =
+            (this.historyIndex - 1 - tap + FILTER_TAPS) % FILTER_TAPS;
+          value +=
+            this.history[index] * this.filters[phase * FILTER_TAPS + tap];
+        }
+        this.appendSample(value);
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('gev-gemini-capture', GeminiCaptureProcessor);

src/voice/geminiDeferredInput.test.mjs

@@ -0,0 +1,285 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  nativeIntegrationFixture,
+  assertSuccessfulZoom,
+} from '../testSupport/geminiIntegrationFixture.mjs';
+
+const options = { concurrency: false, timeout: 5000 };
+const OLD_PCM = 'BAAFAA==';
+const TEXT = 'Zoom in for the owned typed successor';
+
+function exposeCapture(h) {
+  const createAudio = h.controller.createAudio;
+  h.controller.createAudio = (callbacks) => {
+    const audio = createAudio(callbacks);
+    audio.captureCallbacks = callbacks;
+    return audio;
+  };
+}
+
+async function startManual(h) {
+  await h.session.start({ pushToTalk: true });
+  assert.equal(h.session.state, 'listening');
+  assert.equal(h.controller.input.pushToTalkMode, true);
+  assert.equal(Boolean(h.controller.input.pushToTalkKeyHeld), false);
+  return h.sockets.at(-1);
+}
+
+// Explicit fake worklet callbacks retain the native physical-capture path;
+// this helper does not populate controller queues or ownership fields itself.
+function speakAndRelease(h, data) {
+  const c = h.controller;
+  const audio = h.audios.at(-1);
+  c.input.pushToTalkKeyHeld = true;
+  c.input.setMicrophoneEnabled(true);
+  const metadata = audio.metadata;
+  assert.ok(Number.isSafeInteger(metadata?.captureId));
+  audio.captureCallbacks.onAudioStart(metadata);
+  audio.captureCallbacks.onAudio(
+    { data, mimeType: 'audio/pcm;rate=16000' },
+    metadata,
+  );
+  c.input.pushToTalkKeyHeld = false;
+  c.input.setMicrophoneEnabled(false);
+  audio.captureCallbacks.onAudioEnd(metadata);
+  return metadata;
+}
+
+async function prepareDeferredPtt(h) {
+  exposeCapture(h);
+  const socket = await startManual(h);
+  speakAndRelease(h, 'AAABAA=='); // A is submitted and awaits its reply.
+  speakAndRelease(h, 'AgADAA=='); // B is submitted, retiring A.
+  const wireBeforeC = socket.sent.length;
+  const metadata = speakAndRelease(h, OLD_PCM); // C waits behind A's boundary.
+  const owner = h.controller.deferredInput;
+  assert.equal(owner?.kind, 'push-to-talk');
+  assert.equal(owner.captureId, metadata.captureId);
+  assert.equal(
+    socket.sent.length,
+    wireBeforeC,
+    'C must still be wholly deferred',
+  );
+  assert.deepEqual(
+    owner.messages.map((message) =>
+      message.realtimeInput?.activityStart
+        ? 'start'
+        : message.realtimeInput?.audio
+          ? 'audio'
+          : message.realtimeInput?.activityEnd
+            ? 'end'
+            : 'other',
+    ),
+    ['start', 'audio', 'end'],
+  );
+  return { socket, owner, metadata };
+}
+
+async function assertHealthySuccessor(h, socket, callId) {
+  const beforeHeight = h.state.height;
+  await h.tool(callId, socket);
+  assertSuccessfulZoom(h, socket, callId, beforeHeight);
+  assert.equal(h.controller.pendingTools, 0);
+  h.complete(socket); // Native post-tool response boundary, with no output PCM.
+  assert.equal(h.controller.narration.state().tools, 0);
+  assert.equal(h.session.state, 'listening');
+}
+
+for (const mode of ['typed replacement', 'Stop', 'Stop+restart']) {
+  test(
+    `F04-5 deferred PTT flush loses its owner on ${mode}`,
+    options,
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      const { socket: oldSocket, owner } = await prepareDeferredPtt(h);
+      const oldAudio = h.audios.at(-1);
+      let observed = 0;
+      let sentAtObserverReturn;
+      let restart;
+      let stateAtObserverReturn;
+      const unsubscribe = h.session.subscribe((event) => {
+        if (
+          event.type !== 'transcript' ||
+          event.role !== 'user' ||
+          event.text !== '' ||
+          observed
+        )
+          return;
+        observed++;
+        if (mode === 'typed replacement') {
+          assert.equal(h.session.sendText(TEXT), true);
+        } else {
+          h.session.stop();
+          if (mode === 'Stop+restart')
+            restart = h.session.start({ pushToTalk: true });
+        }
+        sentAtObserverReturn = oldSocket.sent.length;
+        stateAtObserverReturn = {
+          epoch: h.controller.epoch,
+          turn: h.controller.turn,
+          replyPending: h.controller.replyPending,
+          forwardedActivityOpen: h.controller.forwardedActivityOpen,
+        };
+      });
+      t.after(unsubscribe);
+
+      h.complete(oldSocket); // A's boundary starts flushing C. C's start emits.
+      assert.equal(
+        observed,
+        1,
+        'must enter the actual flush/onset observer boundary',
+      );
+      assert.ok(
+        stateAtObserverReturn,
+        'observer must complete its replacement action',
+      );
+      assert.deepEqual(
+        oldSocket.sent.slice(sentAtObserverReturn),
+        [],
+        'retired C must send neither queued PCM nor an extra end after the observer returns',
+      );
+      assert.deepEqual(
+        {
+          epoch: h.controller.epoch,
+          turn: h.controller.turn,
+          replyPending: h.controller.replyPending,
+          forwardedActivityOpen: h.controller.forwardedActivityOpen,
+        },
+        stateAtObserverReturn,
+        'old flush must not write successor state',
+      );
+      assert.equal(h.controller.deferredInput, null);
+      assert.equal(
+        h.controller.typedIntent?.text ?? null,
+        mode === 'typed replacement' ? TEXT : null,
+      );
+
+      let successorSocket;
+      if (mode === 'typed replacement') {
+        assert.equal(h.controller.epoch, owner.epoch);
+        assert.notEqual(h.controller.turn, owner.turn);
+        assert.equal(
+          oldSocket.sent.some(
+            (message) => message.realtimeInput?.audio?.data === OLD_PCM,
+          ),
+          false,
+        );
+        const typedIndex = oldSocket.sent.findIndex((message) =>
+          message.clientContent?.turns?.some((turn) =>
+            turn.parts?.some((part) => part.text === TEXT),
+          ),
+        );
+        assert.ok(
+          typedIndex >= 0,
+          'owned replacement must actually reach transport',
+        );
+        // The replacement legitimately closes the already-forwarded C start once.
+        assert.ok(oldSocket.sent[typedIndex - 1]?.realtimeInput?.activityEnd);
+        h.complete(oldSocket); // B's remaining retired boundary, deliberately separate.
+        assert.equal(h.controller.retiredReplyPending, false);
+        assert.equal(h.controller.replyPending, true);
+        successorSocket = oldSocket;
+      } else {
+        assert.equal(oldAudio.closed, true);
+        assert.equal(oldSocket.closed, true);
+        if (!restart) restart = h.session.start({ pushToTalk: true });
+        await restart;
+        successorSocket = h.sockets.at(-1);
+        assert.notEqual(successorSocket, oldSocket);
+        assert.equal(
+          successorSocket.sent.some((message) => message.realtimeInput?.audio),
+          false,
+        );
+        assert.equal(
+          successorSocket.sent.some(
+            (message) => message.realtimeInput?.activityEnd,
+          ),
+          false,
+        );
+        assert.equal(h.session.sendText(TEXT), true);
+      }
+      await assertHealthySuccessor(
+        h,
+        successorSocket,
+        `healthy-after-deferred-${mode}`,
+      );
+    },
+  );
+}
+
+test(
+  'F04-5 deferred typed onSent cannot resurrect replyPending after Stop+restart',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const oldSocket = await h.start();
+    assert.equal(h.session.sendText('A'), true);
+    assert.equal(h.session.sendText('B'), true);
+    assert.equal(h.session.sendText('C deferred text'), true);
+    assert.equal(h.controller.deferredInput?.kind, 'user-text');
+    let restart;
+    let observed = 0;
+    const unsubscribe = h.session.subscribe((event) => {
+      if (
+        event.type !== 'transcript' ||
+        event.role !== 'user' ||
+        event.text !== 'C deferred text'
+      )
+        return;
+      observed++;
+      h.session.stop();
+      restart = h.session.start();
+    });
+    t.after(unsubscribe);
+    h.complete(oldSocket);
+    assert.equal(observed, 1);
+    assert.equal(
+      h.controller.replyPending,
+      false,
+      'old onSent wrapper must not resurrect a stopped reply',
+    );
+    await restart;
+    assert.equal(h.controller.replyPending, false);
+    const socket = h.sockets.at(-1);
+    assert.equal(
+      socket.sent.length,
+      1,
+      'replacement connection should contain setup only',
+    );
+    assert.equal(h.session.sendText(TEXT), true);
+    await assertHealthySuccessor(h, socket, 'healthy-after-deferred-text');
+  },
+);
+
+test(
+  'F04-5 ordinary deferred PTT flush preserves start, PCM and end exactly once',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const { socket } = await prepareDeferredPtt(h);
+    const before = socket.sent.length;
+    h.complete(socket);
+    assert.deepEqual(
+      socket.sent
+        .slice(before)
+        .map((message) =>
+          message.realtimeInput?.activityStart
+            ? 'start'
+            : message.realtimeInput?.audio?.data === OLD_PCM
+              ? 'audio'
+              : message.realtimeInput?.activityEnd
+                ? 'end'
+                : 'other',
+        ),
+      ['start', 'audio', 'end'],
+    );
+    assert.equal(h.controller.deferredInput, null);
+    assert.equal(h.controller.replyPending, true);
+    assert.equal(h.controller.retiredReplyPending, true);
+    h.complete(socket); // B's boundary; C remains the owned submitted input.
+    assert.equal(h.controller.retiredReplyPending, false);
+    assert.equal(h.controller.replyPending, true);
+    await assertHealthySuccessor(h, socket, 'healthy-ordinary-deferred');
+  },
+);

src/voice/geminiIntegration.test.mjs

@@ -0,0 +1,287 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  nativeIntegrationFixture,
+  assertSuccessfulZoom,
+  turnOfEventLoop,
+} from '../testSupport/geminiIntegrationFixture.mjs';
+
+const options = { concurrency: false, timeout: 5000 };
+const resultFor = (h, id) =>
+  h.events.filter(
+    (event) => event.type === 'action-result' && event.callId === id,
+  );
+const callFor = (h, id) =>
+  h.events.filter(
+    (event) => event.type === 'action-call' && event.callId === id,
+  );
+
+test(
+  'native tool reaches actual common session and camera runner without a caption',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const ws = await h.start();
+    h.activity(ws); // Native activity is input framing, not transcript admission.
+    await h.tool('ordinary', ws);
+    assertSuccessfulZoom(h, ws, 'ordinary', 1000);
+    assert.equal(h.runnerCalls.length, 1);
+    assert.equal(h.runnerCalls[0].options.callId, 'ordinary');
+    assert.equal(h.runnerCalls[0].options.signal.aborted, false);
+    assert.equal(h.runnerCalls[0].options.isCurrent(), true);
+    h.complete(ws);
+    assert.equal(h.controller.narration.state().tools, 0);
+    assert.equal(h.controller.narration.state().pendingTimers, 0);
+  },
+);
+
+for (const cancellation of ['stop', 'native interruption']) {
+  test(
+    `${cancellation} discards a stale completed action result; successor changes camera once`,
+    options,
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      const oldSocket = await h.start();
+      h.activity(oldSocket);
+      const gate = h.holdResult('old');
+      const oldDispatch = h.tool('old', oldSocket);
+      const committedResult = await gate.ready;
+      assert.equal(committedResult.ok, true);
+      assert.equal(
+        h.state.height,
+        750,
+        'the legitimate first action committed before cancellation',
+      );
+      assert.equal(callFor(h, 'old').length, 1);
+      assert.deepEqual(resultFor(h, 'old'), []);
+      assert.deepEqual(h.outputs(oldSocket), []);
+
+      if (cancellation === 'stop') h.session.stop();
+      else
+        oldSocket.message({
+          serverContent: { interrupted: true, turnComplete: true },
+        });
+      assert.equal(h.runnerCalls[0].options.signal.aborted, true);
+      assert.equal(h.runnerCalls[0].options.isCurrent(), false);
+      await oldDispatch; // Cancellation must settle before the held result returns.
+      gate.release();
+      await turnOfEventLoop();
+      assert.equal(
+        h.state.height,
+        750,
+        'settling a cancelled result adds no camera mutation',
+      );
+      assert.equal(h.state.zooms.length, 1);
+      assert.deepEqual(resultFor(h, 'old'), []);
+      assert.deepEqual(h.outputs(oldSocket), []);
+      if (cancellation === 'native interruption')
+        assert.ok(h.events.some((event) => event.type === 'interruption'));
+
+      const successorSocket =
+        cancellation === 'stop' ? await h.start() : oldSocket;
+      h.activity(successorSocket);
+      await h.tool('successor', successorSocket);
+      assertSuccessfulZoom(h, successorSocket, 'successor', 750);
+      assert.equal(h.state.zooms.length, 2);
+      assert.equal(h.runnerCalls.length, 2);
+      assert.equal(
+        h.outputs(successorSocket).some((output) => output.id === 'old'),
+        false,
+      );
+      h.complete(successorSocket);
+    },
+  );
+}
+
+for (const phase of ['common connecting', 'adapter connecting']) {
+  test(
+    `Stop from ${phase} observer prevents acquisition and permits fresh Start`,
+    options,
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      let stopped = false;
+      const remove = h.session.subscribe((event) => {
+        const matchingDetail =
+          phase === 'common connecting'
+            ? event.detail === undefined
+            : typeof event.detail === 'string' && event.detail.length > 0;
+        if (
+          !stopped &&
+          event.type === 'state' &&
+          event.state === 'connecting' &&
+          matchingDetail
+        ) {
+          stopped = true;
+          h.session.stop();
+        }
+      });
+      await h.session.start();
+      remove();
+      assert.equal(
+        stopped,
+        true,
+        'the chosen production observer boundary was exercised',
+      );
+      assert.deepEqual(h.acquisitions, {
+        microphone: 0,
+        audio: 0,
+        token: 0,
+        socket: 0,
+      });
+      assert.equal(h.session.state, 'idle');
+      assert.equal(h.controller.narration.state().tools, 0);
+      assert.equal(h.controller.narration.state().pendingTimers, 0);
+      assert.equal(h.clock.timers.size, 0);
+      const ws = await h.start();
+      h.activity(ws);
+      await h.tool('fresh-after-start-cancel', ws);
+      assertSuccessfulZoom(h, ws, 'fresh-after-start-cancel', 1000);
+      h.complete(ws);
+    },
+  );
+}
+
+test(
+  'Stop from common action-call observer prevents runner and leaves no unhandled rejection',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const ws = await h.start();
+    const remove = h.session.subscribe((event) => {
+      if (event.type === 'action-call' && event.callId === 'cancel-at-call')
+        h.session.stop();
+    });
+    h.activity(ws);
+    await h.tool('cancel-at-call', ws);
+    // Do not install a swallowing process rejection listener. node:test records
+    // an unhandled rejection as a failure; these checkpoints let it surface here.
+    await turnOfEventLoop();
+    await turnOfEventLoop();
+    remove();
+    assert.equal(callFor(h, 'cancel-at-call').length, 1);
+    assert.deepEqual(resultFor(h, 'cancel-at-call'), []);
+    assert.equal(h.runnerCalls.length, 0);
+    assert.equal(h.state.height, 1000);
+    assert.deepEqual(h.outputs(ws), []);
+    assert.equal(h.controller.narration.state().tools, 0);
+    assert.equal(h.controller.narration.state().pendingTimers, 0);
+    assert.equal(h.clock.timers.size, 0);
+    const successor = await h.start();
+    h.activity(successor);
+    await h.tool('after-call-cancel', successor);
+    assertSuccessfulZoom(h, successor, 'after-call-cancel', 1000);
+    h.complete(successor);
+  },
+);
+
+test(
+  'Stop from executing observer cannot recreate narration or dispatch the runner',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const ws = await h.start();
+    let stopped = false;
+    const remove = h.session.subscribe((event) => {
+      if (!stopped && event.type === 'state' && event.state === 'executing') {
+        stopped = true;
+        h.session.stop();
+      }
+    });
+    h.activity(ws);
+    await h.tool('cancel-at-executing', ws);
+    remove();
+    assert.equal(stopped, true);
+    assert.equal(h.runnerCalls.length, 0);
+    assert.deepEqual(callFor(h, 'cancel-at-executing'), []);
+    assert.deepEqual(resultFor(h, 'cancel-at-executing'), []);
+    assert.equal(h.state.height, 1000);
+    assert.deepEqual(h.outputs(ws), []);
+    assert.equal(h.controller.narration.state().tools, 0);
+    assert.equal(h.controller.narration.state().pendingTimers, 0);
+    assert.equal(h.clock.timers.size, 0);
+    assert.equal(ws.closed, true);
+    assert.ok(h.audios.every((audio) => audio.closed));
+    assert.ok(h.tracks.every((track) => track.readyState === 'ended'));
+    const before = {
+      events: h.events.length,
+      wire: ws.sent.length,
+      earcon: h.state.earconStarts,
+    };
+    h.clock.advance(60_000);
+    assert.deepEqual(
+      {
+        events: h.events.length,
+        wire: ws.sent.length,
+        earcon: h.state.earconStarts,
+      },
+      before,
+    );
+    const successor = await h.start();
+    h.activity(successor);
+    await h.tool('after-executing-cancel', successor);
+    assertSuccessfulZoom(h, successor, 'after-executing-cancel', 1000);
+    h.complete(successor);
+  },
+);
+
+test(
+  'native idle observer restart remains connecting and public Stop cancels its pending permission',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    await h.start();
+    let grant;
+    const permission = new Promise((resolve) => {
+      grant = resolve;
+    });
+    h.controller.getUserMedia = () => permission;
+    const states = [];
+    let restarted = false;
+    let startup;
+    const remove = h.session.subscribe((event) => {
+      if (event.type === 'state') states.push(event.state);
+      if (!restarted && event.type === 'state' && event.state === 'idle') {
+        restarted = true;
+        startup = h.session.start();
+      }
+    });
+    h.session.stop();
+    remove();
+    assert.equal(restarted, true);
+    assert.equal(states.filter((state) => state === 'idle').length, 1);
+    assert.equal(h.session.state, 'connecting');
+    assert.equal(h.controller.status, 'connecting');
+    assert.equal(
+      h.session.isActive(),
+      true,
+      'the common button/facade must offer Stop',
+    );
+    h.session.stop();
+    assert.equal(h.session.state, 'idle');
+    assert.equal(h.controller.status, 'idle');
+    const lateTrack = {
+      readyState: 'live',
+      stopCalls: 0,
+      stop() {
+        this.stopCalls++;
+        this.readyState = 'ended';
+      },
+    };
+    h.tracks.push(lateTrack);
+    grant({ getTracks: () => [lateTrack], getAudioTracks: () => [lateTrack] });
+    await startup;
+    await turnOfEventLoop();
+    assert.equal(lateTrack.stopCalls, 1);
+    assert.equal(
+      h.requests.length,
+      1,
+      'cancelled restart must not mint another token',
+    );
+    assert.equal(
+      h.sockets.length,
+      1,
+      'cancelled restart must not open another socket',
+    );
+    assert.equal(h.session.state, 'idle');
+  },
+);

src/voice/geminiNativeCaptionEvents.test.mjs

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { harness } from '../testSupport/geminiNativeHarness.mjs';
+
+const caption = (socket, text) =>
+  socket.message({ serverContent: { inputTranscription: { text } } });
+const userEvents = (events) =>
+  events.filter(
+    (event) => event.type === 'transcript' && event.role === 'user',
+  );
+
+test('native caption events preserve received advisory segments without granting tool authority', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    const start = h.events.length;
+    for (const text of ['little. ', 'Zoom in a ']) caption(ws, text);
+    const received = userEvents(h.events.slice(start));
+    assert.deepEqual(
+      received.map((event) => event.text),
+      ['little. ', 'Zoom in a '],
+    );
+    assert.equal(
+      received.every(
+        (event) =>
+          event.delta === true &&
+          event.final === false &&
+          event.attribution === 'unverified' &&
+          event.responseId === null,
+      ),
+      true,
+    );
+    assert.equal(h.c.currentTypedInput(), null);
+    ws.message({
+      toolCall: {
+        functionCalls: [
+          {
+            id: 'ordinary-native',
+            name: 'get_current_view_state',
+            args: {},
+          },
+        ],
+      },
+    });
+    await h.c.toolQueue;
+    assert.equal(h.calls.length, 1);
+    assert.equal(h.calls[0].options.userTurn, undefined);
+    assert.equal(h.calls[0].options.isCurrent(), true);
+    ws.message({ serverContent: { turnComplete: true } });
+    assert.equal(
+      userEvents(h.events.slice(start)).some((event) => event.final),
+      false,
+    );
+  } finally {
+    h.c.stop();
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+test('native old socket captions cannot enter a restarted controller event stream', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const old = h.sockets[0];
+    caption(old, 'old partial');
+    h.c.stop();
+    await h.c.start();
+    const start = h.events.length;
+    const current = h.sockets[1];
+    caption(current, 'Zoom ');
+    caption(old, 'stale old socket');
+    caption(current, 'in a little.');
+    current.message({ serverContent: { turnComplete: true } });
+    assert.deepEqual(
+      userEvents(h.events.slice(start)).map((event) => event.text),
+      ['Zoom ', 'in a little.'],
+    );
+    assert.equal(h.tracks[0].readyState, 'ended');
+    assert.equal(h.captures[0].closed, true);
+  } finally {
+    h.c.stop();
+  }
+  assert.equal(h.timers.size, 0);
+});

src/voice/geminiNativeOwnership.test.mjs

@@ -0,0 +1,667 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  harness,
+  tick,
+  deferred,
+} from '../testSupport/geminiNativeHarness.mjs';
+import { withToolCatalog } from './gevRealtime.js';
+
+const audioContent = (data) => ({
+  modelTurn: {
+    parts: [{ inlineData: { data, mimeType: 'audio/pcm;rate=24000' } }],
+  },
+});
+const request = (ws, id, name = 'get_current_view_state', args = {}) =>
+  ws.message({ toolCall: { functionCalls: [{ id, name, args }] } });
+const responses = (ws) =>
+  ws.sent.flatMap((m) => m.toolResponse?.functionResponses || []);
+const onset = (ws) => {
+  ws.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+  ws.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+};
+const caption = (ws, text) =>
+  ws.message({ serverContent: { inputTranscription: { text } } });
+
+for (const [id, name, args] of [
+  ['H01', 'get_entity_context', {}],
+  ['H02', 'control_radio', { action: 'status' }],
+]) {
+  test(`${id} native: cancelling a current ${name} query preserves unrelated Radio preflight`, async () => {
+    const ready = deferred(),
+      query = deferred(),
+      executions = [];
+    const h = harness({
+      runAction: (name, args, options) => {
+        executions.push({ name, args, options });
+        return args.action === 'play'
+          ? Promise.resolve({
+              ok: true,
+              action: 'control_radio',
+              radioAction: 'play',
+              radioPlaybackRequested: true,
+            })
+          : query.promise;
+      },
+    });
+    h.c.radio.radioLayer.playForVoice = () => ready.promise;
+    try {
+      await h.c.start();
+      h.c.sendTextCommand('Play radio');
+      const ws = h.sockets[0];
+      request(ws, 'owner', 'control_radio', { action: 'play' });
+      await h.c.toolQueue;
+      ws.message({
+        serverContent: { ...audioContent('confirmation'), turnComplete: true },
+      });
+      h.captures[0].drain();
+      assert.equal(h.c.radio.radioHandoffInFlight, true);
+      request(ws, 'query', name, args);
+      await tick();
+      assert.equal(
+        executions.length,
+        2,
+        'current native query may start after provider completion',
+      );
+      const epoch = h.c.radio.radioHandoffEpoch;
+      const pending = h.c.radio.pendingRadioPlaybackResult;
+      const attempt = h.c.radio.radioHandoffAttemptId;
+      const ownerCurrent = executions[0].options.isCurrent();
+      ws.message({ toolCallCancellation: { ids: ['unknown', 'query'] } });
+      await h.c.toolQueue;
+      assert.equal(executions[1].options.signal.aborted, true);
+      assert.equal(executions[1].options.isCurrent(), false);
+      assert.equal(h.c.radio.radioHandoffEpoch, epoch);
+      assert.equal(executions[0].options.signal.aborted, false);
+      assert.equal(executions[0].options.isCurrent(), ownerCurrent);
+      assert.equal(h.c.radio.pendingRadioPlaybackResult, pending);
+      assert.equal(h.c.radio.radioHandoffAttemptId, attempt);
+      assert.equal(h.c.radio.radioHandoffInFlight, true);
+      assert.equal(h.state.stopped, 0);
+      assert.equal(h.c.pendingTools, 0);
+      assert.deepEqual(
+        responses(ws).map((r) => r.id),
+        ['owner'],
+      );
+      assert.equal(responses(ws)[0].response.ok, true);
+      query.resolve({ ok: true });
+      ready.resolve(true);
+      await tick();
+      assert.equal(h.c.status, 'idle');
+      assert.equal(h.state.ducked, false);
+      assert.deepEqual(
+        responses(ws).map((r) => r.id),
+        ['owner'],
+      );
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const [id, prior] of [
+  ['H03', 'playing'],
+  ['H04', 'before-first-output'],
+]) {
+  test(`${id} native: PTT fences ${prior} reply and recovers the new call after its boundary`, async () => {
+    const h = harness();
+    try {
+      await h.c.start({ pushToTalk: true });
+      const ws = h.sockets[0],
+        audio = h.captures[0];
+      if (prior === 'playing')
+        ws.message({ serverContent: audioContent('old') });
+      else {
+        h.c.input.setMicrophoneEnabled(true);
+        audio.callbacks.onAudio(
+          { data: 'AAAB', mimeType: 'audio/pcm;rate=16000' },
+          audio.metadata,
+        );
+        h.c.input.setMicrophoneEnabled(false);
+      }
+      h.c.input.pushToTalkKeyHeld = true;
+      assert.equal(h.c.input.bargeIn(), true);
+      h.c.input.setMicrophoneEnabled(true);
+      h.c.input.setMicrophoneEnabled(false);
+      const turn = h.c.turn,
+        played = audio.played.length,
+        firstEvent = h.events.length;
+      ws.message({
+        serverContent: {
+          ...audioContent('late-old'),
+          outputTranscription: { text: 'retired output' },
+          inputTranscription: { text: 'new request' },
+        },
+      });
+      request(ws, 'retired-call', 'fly_to_location', { query: 'old target' });
+      await h.c.toolQueue;
+      assert.equal(audio.played.length, played);
+      assert.equal(audio.pending, false);
+      assert.equal(h.calls.length, 0);
+      assert.equal(
+        h.events.slice(firstEvent).some((e) => e.role === 'assistant'),
+        false,
+      );
+      assert.equal(
+        h.events
+          .slice(firstEvent)
+          .some((e) => e.role === 'user' && e.text === 'new request'),
+        true,
+      );
+      ws.message({ serverContent: { interrupted: true } });
+      assert.equal(h.c.turn, turn);
+      ws.message({ serverContent: audioContent('after-interrupted') });
+      assert.equal(
+        audio.played.length,
+        played,
+        'interrupted alone cannot release the fence',
+      );
+      ws.message({
+        serverContent: {
+          ...audioContent('boundary-old'),
+          outputTranscription: { text: 'still retired' },
+          turnComplete: true,
+        },
+      });
+      assert.equal(
+        audio.played.length,
+        played,
+        'coalesced old boundary output is discarded',
+      );
+      assert.equal(
+        h.events.slice(firstEvent).some((e) => e.type === 'completion'),
+        false,
+      );
+      caption(ws, 'unrelated advisory words');
+      ws.message({
+        toolCall: {
+          functionCalls: [
+            {
+              id: 'retired-call',
+              name: 'fly_to_location',
+              args: { query: 'replayed old target' },
+            },
+            {
+              id: 'new-call',
+              name: 'fly_to_location',
+              args: { query: 'new target' },
+            },
+          ],
+        },
+      });
+      await h.c.toolQueue;
+      assert.deepEqual(
+        h.calls.map((c) => c.args.query),
+        ['new target'],
+      );
+      assert.equal(h.calls[0].options.userTurn, undefined);
+      ws.message({
+        serverContent: {
+          ...audioContent('new'),
+          outputTranscription: { text: 'new reply' },
+          turnComplete: true,
+        },
+      });
+      assert.equal(audio.played.at(-1).data, 'new');
+      audio.drain();
+      assert.equal(
+        h.events.findLast((e) => e.type === 'completion').status,
+        'completed',
+      );
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+test('H05 native: local typed presentation survives audio drain and new input revokes old call ownership', async () => {
+  const h = harness();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0],
+      audio = h.captures[0];
+    h.c.sendTextCommand('Show the current view');
+    const response = h.c.currentTypedInput();
+    assert.equal(response.text, 'Show the current view');
+    assert.equal(
+      h.events.findLast((e) => e.type === 'transcript' && e.role === 'user')
+        .text,
+      response.text,
+    );
+    request(ws, 'first');
+    await h.c.toolQueue;
+    assert.equal(h.calls[0].options.userTurn, undefined);
+    assert.equal(h.calls[0].options.isCurrent(), true);
+    ws.message({
+      serverContent: {
+        ...audioContent('confirmation'),
+        outputTranscription: { text: 'Here is the current view' },
+        turnComplete: true,
+      },
+    });
+    assert.equal(
+      h.events.some((e) => e.type === 'completion'),
+      false,
+    );
+    assert.equal(
+      h.events.findLast((e) => e.role === 'assistant').responseId,
+      response.responseId,
+    );
+    audio.drain();
+    const completion = h.events.findLast((e) => e.type === 'completion');
+    assert.equal(completion.responseId, response.responseId);
+    assert.equal(completion.spoken, true);
+    assert.equal(completion.audioDrained, true);
+    assert.equal(h.c.currentTypedInput(), response);
+    assert.equal(response.text, 'Show the current view');
+    request(ws, 'same-turn');
+    await h.c.toolQueue;
+    assert.equal(h.calls[1].options.userTurn, undefined);
+    assert.equal(h.c.currentTypedInput(), response);
+    h.c.sendTextCommand('New request');
+    assert.notEqual(h.c.currentTypedInput(), response);
+    assert.equal(h.c.currentTypedInput().text, 'New request');
+    assert.equal(h.calls[0].options.isCurrent(), false);
+    assert.equal(h.calls[1].options.isCurrent(), false);
+  } finally {
+    h.c.stop();
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+test('H08 native: replacing pending runner work cannot underflow tool counts or block successor', async () => {
+  const gate = deferred(),
+    executions = [];
+  const h = harness({
+    runAction: (name, args, options) => {
+      executions.push({ name, args, options });
+      return options.callId === 'old'
+        ? gate.promise
+        : Promise.resolve({ ok: true });
+    },
+  });
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    request(ws, 'old');
+    await tick();
+    const oldWork = h.c.toolQueue;
+    assert.equal(h.c.pendingTools, 1);
+    ws.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+    assert.equal(h.c.pendingTools, 0);
+    await oldWork;
+    assert.equal(h.c.pendingTools, 0);
+    assert.equal(executions[0].options.signal.aborted, true);
+    assert.equal(executions[0].options.isCurrent(), false);
+    ws.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+    ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+    request(ws, 'fresh');
+    await h.c.toolQueue;
+    assert.equal(executions.at(-1).options.callId, 'fresh');
+    assert.equal(h.c.pendingTools, 0);
+    gate.resolve({ ok: true });
+    await tick();
+    assert.equal(h.c.pendingTools, 0);
+    assert.deepEqual(
+      responses(ws).map((r) => r.id),
+      ['fresh'],
+    );
+    ws.message({
+      serverContent: { ...audioContent('fresh reply'), turnComplete: true },
+    });
+    h.captures[0].drain();
+    assert.equal(
+      h.events.findLast((e) => e.type === 'completion').status,
+      'completed',
+    );
+  } finally {
+    h.c.stop();
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+test('H10 native: held speech dispatches without caption authority and new text revokes its call', async () => {
+  const gate = deferred(),
+    executions = [];
+  const h = harness({
+    runAction: (name, args, options) => {
+      executions.push({ name, args, options });
+      return gate.promise;
+    },
+  });
+  try {
+    await h.c.start({ pushToTalk: true });
+    const ws = h.sockets[0],
+      audio = h.captures[0];
+    h.c.input.bargeIn();
+    h.c.input.setMicrophoneEnabled(true);
+    audio.callbacks.onAudio(
+      { data: 'AA==', mimeType: 'audio/pcm;rate=16000' },
+      audio.metadata,
+    );
+    h.c.input.setMicrophoneEnabled(false);
+    caption(ws, 'Show the current view');
+    assert.equal(h.c.currentTypedInput(), null);
+    assert.equal(
+      h.events.findLast((e) => e.type === 'transcript' && e.role === 'user')
+        .text,
+      'Show the current view',
+    );
+    request(ws, 'held');
+    await tick();
+    const oldWork = h.c.toolQueue;
+    assert.equal(executions.length, 1);
+    assert.equal(executions[0].options.userTurn, undefined);
+    assert.equal(executions[0].options.isCurrent(), true);
+    h.c.sendTextCommand('new intent');
+    await oldWork;
+    assert.equal(executions[0].options.signal.aborted, true);
+    assert.equal(executions[0].options.isCurrent(), false);
+    gate.resolve({ ok: true });
+    await tick();
+    assert.equal(
+      responses(ws).some((r) => r.id === 'held'),
+      false,
+    );
+  } finally {
+    h.c.stop();
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+for (const [id, restart] of [
+  ['H11', false],
+  ['H12', true],
+]) {
+  test(`${id} native: pending tool cannot revive voice after Stop${restart ? '/restart' : ''}`, async () => {
+    const gate = deferred(),
+      mutations = [],
+      executions = [];
+    const h = harness({
+      runAction: async (name, args, options) => {
+        executions.push(options);
+        await gate.promise;
+        if (options.isCurrent()) mutations.push(name);
+        return { ok: true };
+      },
+    });
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      onset(ws);
+      request(ws, 'old');
+      await tick();
+      const pending = h.c.toolQueue;
+      assert.equal(h.c.pendingTools, 1);
+      h.c.stop();
+      const boundary = h.events.length;
+      const successor = restart ? h.c.start() : null;
+      await pending;
+      assert.equal(
+        h.events
+          .slice(boundary)
+          .some((e) => e.type === 'state' && e.state === 'listening'),
+        false,
+      );
+      assert.equal(executions[0].signal.aborted, true);
+      assert.equal(executions[0].isCurrent(), false);
+      assert.equal(h.c.pendingTools, 0);
+      if (successor) await successor;
+      const laterBoundary = h.events.length;
+      gate.resolve();
+      caption(ws, 'late old speech');
+      await tick();
+      assert.deepEqual(mutations, []);
+      assert.equal(
+        h.events.slice(laterBoundary).some((e) => e.type === 'state'),
+        false,
+      );
+      assert.equal(responses(ws).length, 0);
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const [id, boundary] of [
+  ['H14', 'interrupted'],
+  ['H15', 'natural'],
+]) {
+  test(`${id} native: shared runner zoom executes promptly after ${boundary} retired boundary`, async () => {
+    const mutations = [],
+      observed = [];
+    const guarded = withToolCatalog(
+      async (name, args) => {
+        mutations.push({ name, args });
+        return { ok: true };
+      },
+      async () => null,
+    );
+    const h = harness({
+      runAction: (name, args, options) => {
+        observed.push(options);
+        return guarded(name, args, options);
+      },
+    });
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      ws.message({ serverContent: audioContent('old reply') });
+      ws.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+      ws.message({
+        serverContent: {
+          ...(boundary === 'interrupted' ? { interrupted: true } : {}),
+          turnComplete: true,
+        },
+      });
+      ws.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+      caption(ws, 'zoom in');
+      request(ws, 'zoom', 'adjust_camera_zoom', { direction: 'in' });
+      await tick();
+      assert.equal(
+        mutations.length,
+        1,
+        'native action executes without a transcript wait',
+      );
+      assert.equal(observed[0].userTurn, undefined);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(
+        responses(ws).some((r) => r.response.voiceIntentUnverified),
+        false,
+      );
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const [id, exit] of [
+  ['H18', 'stop'],
+  ['H19', 'replacement'],
+]) {
+  test(`${id} native: ${exit} prevents queued camera dispatch and late captions cannot revive it`, async () => {
+    const mutations = [],
+      observed = [];
+    const guarded = withToolCatalog(
+      async (name) => {
+        mutations.push(name);
+        return { ok: true };
+      },
+      async () => null,
+    );
+    const h = harness({
+      runAction: (name, args, options) => {
+        observed.push(name);
+        return guarded(name, args, options);
+      },
+    });
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      onset(ws);
+      request(ws, 'queued-old', 'adjust_camera_zoom', { direction: 'in' });
+      const oldWork = h.c.toolQueue;
+      assert.equal(h.c.pendingTools, 1);
+      if (exit === 'stop') h.c.stop();
+      else h.c.sendTextCommand('Show the whole globe');
+      caption(ws, 'zoom in');
+      await oldWork;
+      assert.deepEqual(mutations, []);
+      assert.deepEqual(observed, []);
+      assert.equal(h.c.pendingTools, 0);
+      if (exit === 'replacement') {
+        ws.message({
+          serverContent: { interrupted: true, turnComplete: true },
+        });
+        request(ws, 'fresh-camera', 'zoom_to_globe');
+        await h.c.toolQueue;
+        assert.deepEqual(mutations, ['zoom_to_globe']);
+        assert.deepEqual(observed, ['zoom_to_globe']);
+        assert.equal(responses(ws).at(-1).response.ok, true);
+      }
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const settlement of ['queued', 'running']) {
+  test(`native: cancelled ${settlement} tool settles a completed provider turn`, async () => {
+    const result = deferred();
+    let executions = 0;
+    const h = harness({
+      runAction: () => {
+        executions++;
+        return result.promise;
+      },
+    });
+    try {
+      await h.c.start();
+      h.c.sendTextCommand('Read current view');
+      const ws = h.sockets[0];
+      request(ws, 'cancelled-query');
+      if (settlement === 'running') await tick();
+      ws.message({ toolCallCancellation: { ids: ['cancelled-query'] } });
+      ws.message({ serverContent: { turnComplete: true } });
+      await h.c.toolQueue;
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(executions, settlement === 'queued' ? 0 : 1);
+      assert.deepEqual(responses(ws), []);
+      assert.equal(
+        h.events.filter((event) => event.type === 'completion').length,
+        1,
+      );
+      assert.equal(h.c.pendingCompletionStatus, null);
+      result.resolve({ ok: true });
+      await tick();
+      h.captures[0].drain();
+      assert.equal(
+        h.events.filter((event) => event.type === 'completion').length,
+        1,
+      );
+      assert.deepEqual(responses(ws), []);
+    } finally {
+      result.resolve({ ok: true });
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const order of ['before', 'after']) {
+  test(`native: cancelling queued output ${order} turnComplete emits one completion`, async () => {
+    const h = harness();
+    try {
+      await h.c.start();
+      h.c.sendTextCommand('Read current view');
+      const ws = h.sockets[0];
+      ws.bufferedAmount = 1e9;
+      request(ws, 'queued-output');
+      await h.c.toolQueue;
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(h.c.controlQueue.length, 1);
+      assert.equal(responses(ws).length, 0);
+      if (order === 'after')
+        ws.message({ serverContent: { turnComplete: true } });
+      ws.message({ toolCallCancellation: { ids: ['queued-output'] } });
+      if (order === 'before')
+        ws.message({ serverContent: { turnComplete: true } });
+      assert.equal(h.c.controlQueue.length, 0);
+      assert.equal(h.c.controlTimer, null);
+      assert.equal(h.c.pendingCompletionStatus, null);
+      assert.equal(h.events.filter((e) => e.type === 'completion').length, 1);
+      ws.bufferedAmount = 0;
+      h.advance(1000);
+      h.captures[0].drain();
+      assert.deepEqual(responses(ws), []);
+      assert.equal(h.events.filter((e) => e.type === 'completion').length, 1);
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const successor of ['input', 'stop']) {
+  test(`native: queued-output cancellation completion fences reentrant ${successor}`, async () => {
+    let h;
+    let successorTurn;
+    h = harness({
+      emit: (event) => {
+        h.events.push(event);
+        if (event.type !== 'completion') return;
+        h.sockets[0].bufferedAmount = 0;
+        if (successor === 'stop') h.c.stop();
+        else {
+          h.c.sendTextCommand('Show the whole globe');
+          successorTurn = h.c.turn;
+        }
+      },
+    });
+    try {
+      await h.c.start();
+      h.c.sendTextCommand('Read current view');
+      const ws = h.sockets[0];
+      ws.bufferedAmount = 1e9;
+      request(ws, 'queued-output');
+      await h.c.toolQueue;
+      ws.message({ serverContent: { turnComplete: true } });
+      const callCount = h.calls.length;
+      ws.message({
+        toolCallCancellation: { ids: ['queued-output'] },
+        serverContent: {
+          outputTranscription: { text: 'Retired packet caption' },
+          turnComplete: true,
+        },
+        toolCall: {
+          functionCalls: [
+            { id: 'retired-tool', name: 'get_current_view_state', args: {} },
+          ],
+        },
+      });
+      await h.c.toolQueue;
+      assert.equal(h.events.filter((e) => e.type === 'completion').length, 1);
+      assert.equal(h.calls.length, callCount);
+      assert.deepEqual(responses(ws), []);
+      assert.ok(
+        !h.events.some((e) =>
+          JSON.stringify(e).includes('Retired packet caption'),
+        ),
+      );
+      if (successor === 'input') {
+        assert.equal(h.c.turn, successorTurn);
+        assert.equal(h.c.modelComplete, false);
+        assert.equal(h.c.replyPending, true);
+      } else assert.equal(h.c.isActive(), false);
+    } finally {
+      h.c.stop();
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}

src/voice/geminiNativeRadio.test.mjs

@@ -0,0 +1,734 @@
+// Native ownership replacements for historical Radio regression cases.
+// Real Gemini controller, action runner, DataLayerManager and RealtimeRadio consumers.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  harness,
+  tick,
+  deferred,
+} from '../testSupport/geminiNativeHarness.mjs';
+import { createGevActionRunner } from './gevActions.js';
+import { createVoiceSession } from './session.js';
+import { DataLayerManager } from '../data/manager.js';
+
+const viewerFixture = () => ({
+  clock: { onTick: { addEventListener: () => () => {} } },
+  camera: { moveEnd: { addEventListener() {} } },
+  scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
+});
+const request = (ws, id, name, args = {}) =>
+  ws.message({ toolCall: { functionCalls: [{ id, name, args }] } });
+const responses = (ws) =>
+  ws.sent.flatMap((frame) => frame.toolResponse?.functionResponses || []);
+const responseFor = (ws, id) =>
+  responses(ws).findLast((response) => response.id === id)?.response;
+const speechTurn = (ws) => {
+  ws.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+  ws.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+};
+function drainRadioReply(h) {
+  h.sockets.at(-1).message({
+    serverContent: {
+      modelTurn: { parts: [{ inlineData: { data: 'AAAA' } }] },
+      turnComplete: true,
+    },
+  });
+  h.captures.at(-1).drain();
+}
+
+function radioSiblingFixture() {
+  const viewer = viewerFixture();
+  const manager = new DataLayerManager(viewer);
+  const lookupEntered = deferred();
+  const lookupReleased = deferred();
+  const state = {
+    stationCount: 2,
+    selected: { id: 'existing-station', name: 'Existing Station' },
+    audioState: 'stopped',
+  };
+  const trace = { stops: 0, pauses: 0, selections: 0, options: new Map() };
+  const radio = {
+    async init() {},
+    async enable() {},
+    async disable() {},
+    async update() {},
+    getStats: () => ({ count: 2 }),
+    getUIState: () => ({ ...state }),
+    setVoiceDucked() {},
+    pause({ origin } = {}) {
+      if (origin === 'voice') trace.pauses++;
+      state.audioState = 'paused';
+      return true;
+    },
+    stopPlayback() {
+      trace.stops++;
+      state.audioState = 'stopped';
+      return true;
+    },
+    selectRequestedStation() {
+      trace.selections++;
+      state.selected = { id: 'late-station', name: 'Late Station' };
+      return state.selected;
+    },
+    subscribePlaybackControls: () => () => {},
+  };
+  manager.register(
+    Object.assign(radio, {
+      id: 'radio',
+      name: 'Radio',
+      updateInterval: -1,
+    }),
+  );
+  const runner = createGevActionRunner({
+    viewer,
+    dataManager: manager,
+    placeSearch: {
+      async geocode(_query, { signal }) {
+        trace.lookupSignal = signal;
+        lookupEntered.resolve();
+        // Deliberately ignore abort: production currentness must still prevent
+        // this late service completion from committing a station selection.
+        await lookupReleased.promise;
+        return { place: { lat: 10, lng: 20, label: 'Deferred Place' } };
+      },
+    },
+  });
+  const h = harness({
+    dataManager: manager,
+    radioLayer: radio,
+    runAction(name, args, options) {
+      trace.options.set(options.callId, options);
+      return runner(name, args, options);
+    },
+  });
+  return {
+    h,
+    manager,
+    runner,
+    radio,
+    trace,
+    state,
+    lookupEntered,
+    lookupReleased,
+  };
+}
+
+for (const action of ['select', 'play']) {
+  for (const stronger of ['stop', 'pause', 'disable', 'off']) {
+    test(`native same-turn Radio ${stronger} preempts deferred ${action} without cancelling a query sibling`, async () => {
+      const f = radioSiblingFixture();
+      const { h, trace, state } = f;
+      try {
+        await f.manager.setEnabled('radio', true);
+        await h.c.start();
+        const ws = h.sockets[0];
+        speechTurn(ws);
+        const turn = h.c.turn;
+        request(ws, 'slow-selection', 'control_radio', {
+          action,
+          locationQuery: 'Deferred Place',
+        });
+        await f.lookupEntered.promise;
+        request(ws, 'query-sibling', 'control_radio', { action: 'status' });
+        request(
+          ws,
+          'stronger-radio',
+          stronger === 'off' ? 'set_layer_visibility' : 'control_radio',
+          stronger === 'off'
+            ? { layerId: 'radio', enabled: false }
+            : { action: stronger },
+        );
+        await tick();
+        assert.equal(
+          responseFor(ws, 'stronger-radio')?.ok,
+          true,
+          'stronger control must finish before lookup release',
+        );
+        assert.equal(trace.lookupSignal.aborted, true);
+        await h.c.toolQueue;
+        assert.equal(
+          h.c.turn,
+          turn,
+          'sibling control cannot invent a new turn',
+        );
+        assert.equal(trace.selections, 0);
+        assert.equal(state.selected.id, 'existing-station');
+        assert.equal(responseFor(ws, 'slow-selection').ok, false);
+        assert.match(responseFor(ws, 'slow-selection').error, /cancelled/);
+        assert.equal(
+          responseFor(ws, 'slow-selection').enabled,
+          !['disable', 'off'].includes(stronger),
+        );
+        assert.equal(responseFor(ws, 'query-sibling').ok, true);
+        assert.equal(trace.options.get('query-sibling').signal.aborted, false);
+        assert.equal(
+          responseFor(ws, 'stronger-radio').enabled,
+          !['disable', 'off'].includes(stronger),
+        );
+        assert.equal(trace.stops, stronger === 'stop' ? 1 : 0);
+        assert.equal(trace.pauses, stronger === 'pause' ? 1 : 0);
+        f.lookupReleased.resolve();
+        await tick();
+        assert.equal(trace.selections, 0, 'late lookup cannot commit');
+        assert.equal(h.c.pendingTools, 0);
+        assert.equal(h.c.tools.size, 0);
+        assert.equal(h.c.radio.radioToolHandoffReservations.size, 0);
+        for (const id of ['slow-selection', 'query-sibling', 'stronger-radio'])
+          assert.equal(responses(ws).filter((r) => r.id === id).length, 1);
+      } finally {
+        f.lookupReleased.resolve();
+        h.c.stop();
+        f.runner.dispose();
+        await f.manager.setEnabled('radio', false);
+      }
+      assert.equal(h.timers.size, 0);
+    });
+  }
+}
+
+for (const guard of ['malformed', 'replay', 'invalid-arguments']) {
+  test(`native stronger Radio ${guard} cannot revoke a same-turn lookup`, async () => {
+    const f = radioSiblingFixture();
+    const { h, trace } = f;
+    try {
+      await f.manager.setEnabled('radio', true);
+      await h.c.start();
+      const ws = h.sockets[0];
+      if (guard === 'replay') {
+        request(ws, 'stronger-radio', 'control_radio', { action: 'stop' });
+        await h.c.toolQueue;
+      }
+      speechTurn(ws);
+      if (guard === 'replay')
+        ws.message({
+          serverContent: { interrupted: true, turnComplete: true },
+        });
+      request(ws, 'slow-selection', 'control_radio', {
+        action: 'select',
+        locationQuery: 'Deferred Place',
+      });
+      await f.lookupEntered.promise;
+      const stops = trace.stops;
+      const handoffEpoch = h.c.radio.radioHandoffEpoch;
+      request(
+        ws,
+        guard === 'malformed' ? '\n' : 'stronger-radio',
+        'control_radio',
+        {
+          action: 'stop',
+          ...(guard === 'invalid-arguments'
+            ? { latitude: 91, longitude: 0 }
+            : {}),
+        },
+      );
+      await tick();
+      assert.equal(trace.lookupSignal.aborted, false);
+      assert.equal(trace.stops, stops);
+      assert.equal(h.c.radio.radioHandoffEpoch, handoffEpoch);
+      assert.equal(h.c.radio.radioToolHandoffReservations.size, 0);
+      if (guard === 'invalid-arguments') {
+        assert.equal(responseFor(ws, 'stronger-radio').ok, false);
+        assert.match(responseFor(ws, 'stronger-radio').error, /coordinates/);
+      }
+      f.lookupReleased.resolve();
+      await h.c.toolQueue;
+      assert.equal(
+        trace.selections,
+        1,
+        'older eligible work retains authority',
+      );
+      assert.equal(responseFor(ws, 'slow-selection').ok, true);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(h.c.tools.size, 0);
+    } finally {
+      f.lookupReleased.resolve();
+      h.c.stop();
+      f.runner.dispose();
+      await f.manager.setEnabled('radio', false);
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+test('native failed Stop releases its reservation and lets the older selection finish', async () => {
+  const f = radioSiblingFixture();
+  const { h, trace } = f;
+  const stopReleased = deferred();
+  f.radio.stopPlayback = () => stopReleased.promise;
+  try {
+    await f.manager.setEnabled('radio', true);
+    await h.c.start();
+    const ws = h.sockets[0];
+    speechTurn(ws);
+    request(ws, 'slow-selection', 'control_radio', {
+      action: 'select',
+      locationQuery: 'Deferred Place',
+    });
+    await f.lookupEntered.promise;
+    request(ws, 'failed-stop', 'control_radio', { action: 'stop' });
+    await tick();
+    assert.equal(h.c.radio.radioToolHandoffReservations.size, 1);
+    assert.equal(
+      trace.lookupSignal.aborted,
+      false,
+      'provisional Stop cannot revoke work',
+    );
+    assert.equal(h.c.pendingTools, 2);
+    stopReleased.resolve(false);
+    await tick();
+    assert.equal(responseFor(ws, 'failed-stop').ok, false);
+    assert.match(responseFor(ws, 'failed-stop').error, /could not be stopped/);
+    assert.equal(h.c.radio.radioToolHandoffReservations.size, 0);
+    assert.equal(trace.lookupSignal.aborted, false);
+    f.lookupReleased.resolve();
+    await h.c.toolQueue;
+    assert.equal(responseFor(ws, 'slow-selection').ok, true);
+    assert.equal(trace.selections, 1);
+    assert.equal(f.state.selected.id, 'late-station');
+    assert.equal(h.c.pendingTools, 0);
+  } finally {
+    stopReleased.resolve(false);
+    f.lookupReleased.resolve();
+    h.c.stop();
+    f.runner.dispose();
+    await f.manager.setEnabled('radio', false);
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+test('native pending Stop preserves selection completed before its own successful settlement', async () => {
+  const f = radioSiblingFixture();
+  const { h } = f;
+  const stopReleased = deferred();
+  f.radio.stopPlayback = () => stopReleased.promise;
+  try {
+    await f.manager.setEnabled('radio', true);
+    await h.c.start();
+    const ws = h.sockets[0];
+    speechTurn(ws);
+    request(ws, 'slow-selection', 'control_radio', {
+      action: 'select',
+      locationQuery: 'Deferred Place',
+    });
+    await f.lookupEntered.promise;
+    request(ws, 'pending-stop', 'control_radio', { action: 'stop' });
+    await tick();
+    f.lookupReleased.resolve();
+    await tick();
+    assert.equal(responseFor(ws, 'slow-selection').ok, true);
+    assert.equal(f.state.selected.id, 'late-station');
+    assert.equal(h.c.radio.radioToolHandoffReservations.size, 1);
+    assert.ok(h.c.radio.pendingRadioPlaybackResult);
+    stopReleased.resolve(true);
+    await h.c.toolQueue;
+    assert.equal(responseFor(ws, 'pending-stop').ok, true);
+    assert.equal(responseFor(ws, 'pending-stop').stationId, 'late-station');
+    assert.equal(f.state.selected.id, 'late-station');
+    assert.equal(h.c.radio.pendingRadioPlaybackResult, null);
+    assert.equal(h.c.pendingTools, 0);
+  } finally {
+    stopReleased.resolve(false);
+    f.lookupReleased.resolve();
+    h.c.stop();
+    f.runner.dispose();
+    await f.manager.setEnabled('radio', false);
+  }
+  assert.equal(h.timers.size, 0);
+});
+
+for (const restart of [false, true]) {
+  test(`native Stop${restart ? '/restart' : ''} retires concurrent stronger Radio work without late output or count underflow`, async () => {
+    const f = radioSiblingFixture();
+    const { h } = f;
+    const stopReleased = deferred();
+    f.radio.stopPlayback = () => stopReleased.promise;
+    try {
+      await f.manager.setEnabled('radio', true);
+      await h.c.start();
+      const ws = h.sockets[0];
+      speechTurn(ws);
+      request(ws, 'slow-selection', 'control_radio', {
+        action: 'select',
+        locationQuery: 'Deferred Place',
+      });
+      await f.lookupEntered.promise;
+      request(ws, 'pending-stop', 'control_radio', { action: 'stop' });
+      await tick();
+      const oldDrain = h.c.toolQueue;
+      const stopOptions = f.trace.options.get('pending-stop');
+      assert.equal(h.c.pendingTools, 2);
+      h.c.stop();
+      assert.equal(stopOptions.signal.aborted, true);
+      assert.equal(f.trace.lookupSignal.aborted, true);
+      if (restart) {
+        await h.c.start();
+        request(h.sockets[1], 'new-query', 'control_radio', {
+          action: 'status',
+        });
+        await h.c.toolQueue;
+        assert.equal(responseFor(h.sockets[1], 'new-query').ok, true);
+      }
+      stopReleased.resolve(true);
+      f.lookupReleased.resolve();
+      await oldDrain;
+      await tick();
+      assert.equal(responseFor(ws, 'pending-stop'), undefined);
+      assert.equal(responseFor(ws, 'slow-selection'), undefined);
+      assert.equal(f.trace.selections, 0);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(h.c.tools.size, 0);
+      assert.equal(h.c.radio.radioToolHandoffReservations.size, 0);
+      assert.equal(h.c.isActive(), restart);
+    } finally {
+      stopReleased.resolve(false);
+      f.lookupReleased.resolve();
+      h.c.stop();
+      f.runner.dispose();
+      await f.manager.setEnabled('radio', false);
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const phase of ['prepared', 'preflight']) {
+  test(`native same-turn Stop revokes only voice-owned ${phase} playback and preserves completed station`, async () => {
+    const f = radioSiblingFixture();
+    const { h } = f;
+    const ready = deferred();
+    const stopped = [];
+    let preflight;
+    f.radio.playForVoice = () => ready.promise;
+    f.radio.stopPlayback = (options) => {
+      stopped.push(options);
+      return true;
+    };
+    try {
+      await f.manager.setEnabled('radio', true);
+      await h.c.start();
+      const ws = h.sockets[0];
+      speechTurn(ws);
+      request(ws, 'prepared-play', 'control_radio', { action: 'play' });
+      await h.c.toolQueue;
+      assert.equal(
+        responseFor(ws, 'prepared-play').radioPlaybackRequested,
+        true,
+      );
+      if (phase === 'preflight')
+        preflight = h.c.radio.startPendingRadioHandoff();
+      const attemptId = h.c.radio.radioHandoffAttemptId;
+      request(ws, 'stronger-stop', 'control_radio', { action: 'stop' });
+      await h.c.toolQueue;
+      assert.equal(responseFor(ws, 'stronger-stop').ok, true);
+      assert.equal(f.state.selected.id, 'existing-station');
+      assert.equal(h.c.radio.pendingRadioPlaybackResult, null);
+      assert.equal(h.c.radio.radioHandoffInFlight, false);
+      const cleanups = stopped.filter((o) => o.origin === 'voice-cleanup');
+      assert.deepEqual(
+        cleanups,
+        phase === 'preflight' ? [{ origin: 'voice-cleanup', attemptId }] : [],
+      );
+      ready.resolve(true);
+      await preflight;
+      await tick();
+      assert.equal(
+        h.c.isActive(),
+        true,
+        'late old readiness cannot stop voice',
+      );
+      assert.equal(h.c.radio.radioToolHandoffReservations.size, 0);
+      assert.equal(h.c.pendingTools, 0);
+    } finally {
+      ready.resolve(false);
+      h.c.stop();
+      await preflight;
+      f.runner.dispose();
+      await f.manager.setEnabled('radio', false);
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const phase of ['prepared', 'preflight', 'settling']) {
+  test(`native Radio cancellation: ${phase} preserves selection truth and prevents stale speaker transfer`, async () => {
+    const viewer = viewerFixture();
+    const manager = new DataLayerManager(viewer);
+    const prepared = deferred();
+    const settleResult = deferred();
+    const playbackReady = deferred();
+    let playCalls = 0;
+    let stopCalls = 0;
+    let selections = 0;
+    let activeOptions;
+    const state = {
+      stationCount: 2,
+      selected: null,
+      audioState: 'stopped',
+      voiceDucked: false,
+    };
+    const radio = {
+      async init() {},
+      async enable() {},
+      async disable() {},
+      async update() {},
+      getStats: () => ({ count: 2 }),
+      getUIState: () => ({ ...state }),
+      setVoiceDucked(value) {
+        state.voiceDucked = value;
+      },
+      pause() {
+        state.audioState = 'paused';
+      },
+      subscribePlaybackControls() {
+        return () => {};
+      },
+      selectRequestedStation(_criteria, options) {
+        assert.equal(options.autoplay, false);
+        selections++;
+        state.selected = { id: 'station-1', name: 'Station One' };
+        return state.selected;
+      },
+      playForVoice() {
+        playCalls++;
+        return playbackReady.promise;
+      },
+      stopPlayback() {
+        stopCalls++;
+        state.audioState = 'stopped';
+      },
+    };
+    manager.register({
+      id: 'radio',
+      name: 'Radio',
+      updateInterval: -1,
+      ...radio,
+    });
+    const runner = createGevActionRunner({ viewer, dataManager: manager });
+    let h;
+    let preflight;
+    const session = createVoiceSession({
+      runner: async (name, args, options) => {
+        activeOptions = options;
+        const result = await runner(name, args, options);
+        prepared.resolve(result);
+        if (phase === 'settling') await settleResult.promise;
+        return result;
+      },
+      createAdapter: (shared) => {
+        h = harness({ ...shared, dataManager: manager, radioLayer: radio });
+        return {
+          start: (settings) => h.c.start(settings),
+          stop: (settings) => h.c.stop(settings),
+          sendText: (text) => h.c.sendTextCommand(text),
+          sendMapEvent: (event) => h.c.notifyMapEvent(event),
+        };
+      },
+    });
+    try {
+      await session.start();
+      const ws = h.sockets[0];
+      assert.equal(session.sendText('Select Station One on Radio'), true);
+      request(ws, 'prepared-radio', 'control_radio', {
+        action: 'select',
+        stationQuery: 'Station One',
+      });
+      const actual = await prepared.promise;
+      assert.equal(actual.ok, true);
+      assert.equal(actual.radioPlaybackRequested, true);
+      assert.equal(actual.stationId, 'station-1');
+      assert.equal(manager.isEnabled('radio'), true);
+      if (phase !== 'settling') {
+        await h.c.toolQueue;
+        assert.ok(h.c.radio.pendingRadioPlaybackResult);
+      }
+      if (phase === 'preflight') {
+        preflight = h.c.radio.startPendingRadioHandoff();
+        assert.equal(h.c.radio.radioHandoffInFlight, true);
+        assert.equal(playCalls, 1);
+      }
+      // Native call ownership revokes only this deferred playback. No caption
+      // parsing or caption-driven provider policy participates in cancellation.
+      ws.message({ toolCallCancellation: { ids: ['prepared-radio'] } });
+      if (phase === 'settling')
+        assert.equal(activeOptions.signal.aborted, true);
+      settleResult.resolve();
+      await h.c.toolQueue;
+      assert.equal(h.c.radio.pendingRadioPlaybackResult, null);
+      assert.equal(h.c.radio.radioHandoffInFlight, false);
+      assert.equal(manager.isEnabled('radio'), true);
+      assert.equal(state.selected.id, 'station-1');
+      assert.equal(selections, 1);
+      const modelResult = responseFor(ws, 'prepared-radio');
+      if (phase === 'settling')
+        assert.equal(
+          modelResult,
+          undefined,
+          'cancelled active call never sends a late result',
+        );
+      else {
+        assert.equal(modelResult.ok, true);
+        assert.equal(modelResult.stationId, 'station-1');
+      }
+      const stopsAfterCancellation = stopCalls;
+      assert.equal(stopsAfterCancellation, phase === 'preflight' ? 1 : 0);
+      drainRadioReply(h);
+      playbackReady.resolve(true);
+      await preflight;
+      await tick();
+      assert.equal(
+        playCalls,
+        phase === 'preflight' ? 1 : 0,
+        'drain cannot revive cancelled playback',
+      );
+      assert.equal(h.c.isActive(), true, 'late readiness cannot stop voice');
+      assert.equal(h.c.radio.radioHandoffInFlight, false);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(h.c.tools.size, 0);
+      assert.equal(session.sendText('Play radio'), true);
+      request(ws, 'fresh-radio', 'control_radio', { action: 'play' });
+      await h.c.toolQueue;
+      assert.ok(h.c.radio.pendingRadioPlaybackResult);
+      drainRadioReply(h);
+      await tick();
+      assert.equal(playCalls, phase === 'preflight' ? 2 : 1);
+      assert.equal(
+        h.c.isActive(),
+        false,
+        'fresh typed Radio handoff alone ends voice',
+      );
+    } finally {
+      settleResult.resolve();
+      playbackReady.resolve(false);
+      session.destroy();
+      await preflight;
+      runner.dispose();
+      await manager.setEnabled('radio', false);
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+// A stronger Radio control skips the ordered queue. An older Radio call still
+// queued behind a slow sibling must not start after that control succeeded,
+// while a failed control or a later call in the same turn keeps its order.
+for (const [label, ids, stopOk, expectPending] of [
+  [
+    'older queued select is revoked by a later successful stop',
+    ['slow', 'sel', 'stop'],
+    true,
+    false,
+  ],
+  [
+    'a failed stop leaves the older queued select current',
+    ['slow', 'sel', 'stop'],
+    false,
+    true,
+  ],
+  [
+    'a select after the stop in the same turn still runs',
+    ['slow', 'stop', 'sel'],
+    true,
+    true,
+  ],
+]) {
+  test(`stronger Radio ordering: ${label}`, async () => {
+    const viewer = viewerFixture();
+    const manager = new DataLayerManager(viewer);
+    const state = {
+      stationCount: 2,
+      selected: { id: 'existing', name: 'Existing' },
+      audioState: 'stopped',
+    };
+    const radio = {
+      id: 'radio',
+      name: 'Radio',
+      updateInterval: -1,
+      async init() {},
+      async enable() {},
+      async disable() {},
+      async update() {},
+      getStats: () => ({ count: 2 }),
+      getUIState: () => ({ ...state }),
+      setVoiceDucked() {},
+      pause() {
+        state.audioState = 'paused';
+        return true;
+      },
+      stopPlayback() {
+        state.audioState = 'stopped';
+        return stopOk;
+      },
+      selectRequestedStation() {
+        state.selected = { id: 'late', name: 'Late' };
+        return state.selected;
+      },
+      async playForVoice() {
+        return true;
+      },
+      subscribePlaybackControls: () => () => {},
+    };
+    manager.register(radio);
+    const runner = createGevActionRunner({
+      viewer,
+      dataManager: manager,
+      placeSearch: {
+        async geocode() {
+          return { place: { lat: 10, lng: 20, label: 'Place' } };
+        },
+      },
+    });
+    const slow = deferred();
+    const h = harness({
+      dataManager: manager,
+      radioLayer: radio,
+      async runAction(name, args, options) {
+        if (name === 'slow_sibling') {
+          await slow.promise;
+          return { ok: true, action: 'slow_sibling' };
+        }
+        if (name === 'control_radio' && args.action === 'stop' && !stopOk)
+          return {
+            ok: false,
+            action: 'control_radio',
+            error: 'Radio stop failed',
+          };
+        return runner(name, args, options);
+      },
+    });
+    const calls = {
+      slow: { id: 'slow', name: 'slow_sibling', args: {} },
+      sel: {
+        id: 'sel',
+        name: 'control_radio',
+        args: { action: 'select', locationQuery: 'Place' },
+      },
+      stop: { id: 'stop', name: 'control_radio', args: { action: 'stop' } },
+    };
+    try {
+      await manager.setEnabled('radio', true);
+      await h.c.start();
+      const ws = h.sockets[0];
+      speechTurn(ws);
+      ws.message({ toolCall: { functionCalls: ids.map((id) => calls[id]) } });
+      await tick();
+      assert.equal(
+        responseFor(ws, 'stop')?.ok,
+        stopOk,
+        'stop settles without waiting',
+      );
+      slow.resolve();
+      await h.c.toolQueue;
+      await tick();
+      assert.equal(
+        Boolean(h.c.radio.pendingRadioPlaybackResult),
+        expectPending,
+      );
+      assert.equal(responseFor(ws, 'sel')?.ok, expectPending);
+    } finally {
+      slow.resolve();
+      h.c.stop();
+      runner.dispose();
+      await manager.setEnabled('radio', false);
+    }
+    assert.equal(h.timers.size, 0);
+  });
+}

src/voice/geminiNativeRecovery.test.mjs

@@ -0,0 +1,280 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  harness,
+  tick,
+  deferred,
+} from '../testSupport/geminiNativeHarness.mjs';
+import { createGevActionRunner } from './gevActions.js';
+
+const tool = (ws, id) =>
+  ws.message({
+    toolCall: {
+      functionCalls: [
+        {
+          id,
+          name: 'adjust_camera_zoom',
+          args: { direction: 'in', amount: 'little' },
+        },
+      ],
+    },
+  });
+const caption = (ws, text) =>
+  ws.message({ serverContent: { inputTranscription: { text } } });
+const onset = (ws) => {
+  ws.message({ voiceActivity: { type: 'ACTIVITY_START' } });
+  ws.message({ voiceActivity: { type: 'ACTIVITY_END' } });
+};
+const complete = (ws) => ws.message({ serverContent: { turnComplete: true } });
+const oldAudio = {
+  serverContent: {
+    modelTurn: {
+      parts: [
+        {
+          inlineData: {
+            data: 'AAAA',
+            mimeType: 'audio/pcm;rate=24000',
+          },
+        },
+      ],
+    },
+  },
+};
+const outputs = (ws) =>
+  ws.sent.flatMap((m) => m.toolResponse?.functionResponses || []);
+
+// Socket/media are deterministic. Mutations use the production action runner.
+function fixture({ holdFirst = false } = {}) {
+  const state = { height: 1000, renders: 0, providerWrites: [], panels: [] };
+  const position = { x: 6379137, y: 0, z: 0 };
+  const viewer = {
+    clock: { onTick: { addEventListener: () => () => {} } },
+    camera: {
+      positionWC: position,
+      positionCartographic: { height: 1000 },
+      moveEnd: { addEventListener() {} },
+      cancelFlight() {},
+      zoomIn(n) {
+        position.x -= n;
+        state.height -= n;
+        this.positionCartographic.height = state.height;
+      },
+      zoomOut(n) {
+        position.x += n;
+        state.height += n;
+        this.positionCartographic.height = state.height;
+      },
+    },
+    scene: {
+      canvas: {
+        clientWidth: 800,
+        clientHeight: 600,
+        addEventListener() {},
+        removeEventListener() {},
+      },
+      requestRender() {
+        state.renders++;
+      },
+    },
+  };
+  const runner = createGevActionRunner({
+    viewer,
+    dataManager: { layers: new Map() },
+    styleManager: {
+      setVoiceProvider: (p) => state.providerWrites.push(p),
+      setPanelCollapsed: (...args) => state.panels.push(args),
+    },
+  });
+  const entered = [];
+  const gate = deferred();
+  const h = harness({
+    runAction: async (name, args, options) => {
+      entered.push({ name, args, options });
+      if (holdFirst && entered.length === 1) await gate.promise;
+      if (!options.isCurrent())
+        return { ok: false, action: name, changed: false };
+      return runner(name, args, options);
+    },
+  });
+  return {
+    ...h,
+    state,
+    entered,
+    gate,
+    close() {
+      gate.resolve();
+      h.c.stop();
+      runner.dispose();
+      assert.equal(h.timers.size, 0);
+      assert.deepEqual(state.providerWrites, []);
+      assert.deepEqual(state.panels, []);
+    },
+  };
+}
+
+for (const [id, order] of [
+  ['H20', 'before-boundary'],
+  ['H21', 'after-boundary'],
+]) {
+  test(`native replacement ${id}: ${order} tool respects retired output and next onset recovers`, async () => {
+    const h = fixture();
+    try {
+      await h.c.start();
+      const ws = h.sockets[0];
+      ws.message(oldAudio);
+      onset(ws);
+      caption(ws, 'zoom in');
+      if (order === 'before-boundary') {
+        tool(ws, 'ambiguous-before');
+        await tick();
+        assert.equal(h.state.height, 1000);
+        assert.equal(h.entered.length, 0);
+        assert.equal(outputs(ws).length, 0);
+      }
+      ws.message({ serverContent: { interrupted: true, turnComplete: true } });
+      if (order === 'after-boundary') {
+        tool(ws, 'native-after');
+        await h.c.toolQueue;
+        assert.equal(h.state.height, 750);
+        assert.equal(h.entered.length, 1);
+        assert.equal(outputs(ws).at(-1).response.ok, true);
+        complete(ws);
+      }
+      onset(ws);
+      caption(ws, 'zoom in');
+      tool(ws, 'fresh-clean-onset');
+      await h.c.toolQueue;
+      assert.equal(h.state.height, order === 'before-boundary' ? 750 : 562.5);
+      assert.equal(h.entered.length, order === 'before-boundary' ? 1 : 2);
+      assert.equal(h.entered.at(-1).options.userTurn, undefined);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(
+        outputs(ws).some((o) => o.id === 'ambiguous-before'),
+        false,
+      );
+      assert.equal(
+        outputs(ws).find((o) => o.id === 'fresh-clean-onset').response.ok,
+        true,
+      );
+    } finally {
+      h.close();
+    }
+  });
+}
+
+test('native replacement H30: ordinary tools run promptly and late caption fragments cannot strand siblings', async () => {
+  const h = fixture();
+  try {
+    await h.c.start();
+    const ws = h.sockets[0];
+    onset(ws);
+    caption(ws, 'switch to');
+    tool(ws, 'ordinary-before-caption-resolution');
+    await tick();
+    await h.c.toolQueue;
+    assert.equal(h.state.height, 750);
+    assert.equal(h.c.pendingTools, 0);
+    h.advance(1499);
+    caption(ws, 'Austin');
+    h.advance(5000);
+    tool(ws, 'released-sibling');
+    await h.c.toolQueue;
+    assert.equal(h.state.height, 562.5);
+    assert.equal(h.entered.length, 2);
+    assert.equal(
+      h.entered.every((c) => c.options.userTurn === undefined),
+      true,
+    );
+    assert.equal(outputs(ws).length, 2);
+    assert.equal(
+      outputs(ws).every((o) => o.response.ok),
+      true,
+    );
+    assert.equal(h.c.pendingTools, 0);
+    assert.equal(h.c.status, 'listening');
+  } finally {
+    h.close();
+  }
+});
+
+for (const [id, exit] of [
+  ['H32', 'stop'],
+  ['H33', 'restart'],
+  ['H34', 'new-input'],
+]) {
+  test(`native replacement ${id}: ${exit} retires owned in-flight work and late callbacks`, async () => {
+    const h = fixture({ holdFirst: true });
+    try {
+      await h.c.start();
+      let ws = h.sockets[0];
+      onset(ws);
+      caption(ws, 'switch to');
+      tool(ws, 'old-owned-action');
+      await tick();
+      assert.equal(h.entered.length, 1);
+      assert.equal(h.c.pendingTools, 1);
+      assert.equal(h.state.height, 1000);
+      const oldWork = h.c.toolQueue;
+      const oldMessage = ws.onmessage;
+      const oldOwner = h.entered[0].options;
+      if (exit === 'new-input') h.c.sendTextCommand('zoom out');
+      else h.c.stop();
+      assert.equal(oldOwner.signal.aborted, true);
+      assert.equal(oldOwner.isCurrent(), false);
+      if (exit === 'restart') {
+        await h.c.start();
+        ws = h.sockets.at(-1);
+      }
+      if (exit !== 'new-input')
+        oldMessage({
+          data: JSON.stringify({
+            toolCall: {
+              functionCalls: [
+                {
+                  id: 'late-old-call',
+                  name: 'adjust_camera_zoom',
+                  args: { direction: 'in' },
+                },
+              ],
+            },
+          }),
+        });
+      caption(ws, 'Gemini');
+      h.advance(1500);
+      h.gate.resolve();
+      await oldWork;
+      await tick();
+      assert.equal(h.state.height, 1000);
+      assert.equal(h.c.pendingTools, 0);
+      assert.equal(
+        outputs(ws).some(
+          (o) => o.id === 'old-owned-action' || o.id === 'late-old-call',
+        ),
+        false,
+      );
+      if (exit === 'stop') {
+        assert.equal(h.c.status, 'idle');
+        assert.equal(h.c.isActive(), false);
+      } else {
+        if (exit === 'new-input') {
+          ws.message({
+            serverContent: { interrupted: true, turnComplete: true },
+          });
+        } else h.c.sendTextCommand('zoom out');
+        tool(ws, 'fresh-after-retirement');
+        await h.c.toolQueue;
+        assert.equal(h.state.height, 750);
+        assert.equal(h.entered.length, 2);
+        assert.equal(
+          outputs(ws).find((o) => o.id === 'fresh-after-retirement').response
+            .ok,
+          true,
+        );
+        assert.equal(h.c.pendingTools, 0);
+        assert.equal(h.c.isActive(), true);
+      }
+    } finally {
+      h.close();
+    }
+  });
+}

src/voice/geminiPacketOwnership.test.mjs

@@ -0,0 +1,529 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  nativeIntegrationFixture,
+  assertSuccessfulZoom,
+  turnOfEventLoop,
+} from '../testSupport/geminiIntegrationFixture.mjs';
+
+const options = { concurrency: false, timeout: 5000 };
+const OLD_TEXT = 'Old packet caption.';
+const OLD_PCM = 'AAABAA==';
+const POST_TOOL_PCM = 'AgADAA==';
+const OLD_CALL = 'old-coalesced-call';
+
+function coalescedPacket(callId = OLD_CALL) {
+  return {
+    serverContent: {
+      outputTranscription: { text: OLD_TEXT },
+      modelTurn: {
+        parts: [
+          { inlineData: { data: OLD_PCM, mimeType: 'audio/pcm;rate=24000' } },
+        ],
+      },
+      turnComplete: true,
+    },
+    toolCall: {
+      functionCalls: [
+        {
+          id: callId,
+          name: 'adjust_camera_zoom',
+          args: { direction: 'in', amount: 'little' },
+        },
+      ],
+    },
+  };
+}
+
+// Local test observations wrap only injected device fakes and the actual
+// scheduler methods, delegating unchanged. No frozen fixture file is modified.
+function observePacketEffects(h) {
+  const played = [];
+  const narration = { audible: 0, toolStarted: 0, toolFinished: 0 };
+  const createAudio = h.controller.createAudio;
+  h.controller.createAudio = (callbacks) => {
+    const audio = createAudio(callbacks);
+    const play = audio.play.bind(audio);
+    audio.play = (data, mimeType) => {
+      played.push({ audio, data, mimeType });
+      return play(data, mimeType);
+    };
+    return audio;
+  };
+  for (const method of Object.keys(narration)) {
+    const invoke = h.controller.narration[method].bind(h.controller.narration);
+    h.controller.narration[method] = (...args) => {
+      narration[method]++;
+      return invoke(...args);
+    };
+  }
+  return { played, narration };
+}
+
+function packetState(h) {
+  const c = h.controller;
+  return {
+    epoch: c.epoch,
+    inputGeneration: c.inputGeneration,
+    turn: c.turn,
+    completedTurns: c.completedTurns,
+    pendingTools: c.pendingTools,
+    modelComplete: c.modelComplete,
+    pendingCompletionStatus: c.pendingCompletionStatus,
+    postToolOutput: c.postToolOutput,
+    modelSpoke: c.modelSpoke,
+    assistant: c.transcripts.assistant,
+    replyPending: c.replyPending,
+    retiredReplyPending: c.retiredReplyPending,
+    typedText: c.typedIntent?.text ?? null,
+    typedResponseId: c.typedIntent?.responseId ?? null,
+    narrationTools: c.narration.state().tools,
+    narrationTimers: c.narration.state().pendingTimers,
+    ownedTimers: h.clock.timers.size,
+  };
+}
+
+const completions = (h) =>
+  h.events.filter((event) => event.type === 'completion');
+const toolEvents = (h, callId) =>
+  h.events.filter(
+    (event) =>
+      ['action-call', 'action-result', 'progress'].includes(event.type) &&
+      event.callId === callId,
+  );
+
+function assertOldRemainderAbsent(h, observed) {
+  assert.equal(h.state.height, 1000);
+  assert.deepEqual(h.state.zooms, []);
+  assert.deepEqual(h.runnerCalls, []);
+  assert.deepEqual(toolEvents(h, OLD_CALL), []);
+  assert.deepEqual(observed.played, []);
+  assert.deepEqual(observed.narration, {
+    audible: 0,
+    toolStarted: 0,
+    toolFinished: 0,
+  });
+  assert.deepEqual(completions(h), []);
+  assert.equal(h.controller.completedTurns, 0);
+  assert.equal(h.controller.pendingTools, 0);
+  assert.equal(
+    h.events.filter(
+      (event) =>
+        event.type === 'transcript' &&
+        event.role === 'assistant' &&
+        event.final &&
+        event.text === OLD_TEXT,
+    ).length,
+    0,
+  );
+  for (const socket of h.sockets)
+    assert.equal(
+      h.outputs(socket).some((output) => output.id === OLD_CALL),
+      false,
+    );
+}
+
+for (const mode of ['Stop', 'Stop then Start', 'typed successor']) {
+  test(
+    `assistant transcript observer ${mode} fences the rest of a coalesced native packet`,
+    options,
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      const observed = observePacketEffects(h);
+      const oldSocket = await h.start();
+      const oldAudio = h.audios[0];
+      h.activity(oldSocket);
+      const before = packetState(h);
+      let reached = false;
+      let restart;
+      let typedAccepted;
+      let afterObserver;
+      const remove = h.session.subscribe((event) => {
+        if (
+          reached ||
+          event.type !== 'transcript' ||
+          event.role !== 'assistant' ||
+          event.final ||
+          event.text !== OLD_TEXT
+        )
+          return;
+        reached = true;
+        if (mode === 'typed successor') {
+          typedAccepted = h.session.sendText('Zoom in for the typed successor');
+        } else {
+          h.session.stop();
+          if (mode === 'Stop then Start') restart = h.session.start();
+        }
+        afterObserver = packetState(h);
+      });
+      oldSocket.message(coalescedPacket());
+      remove();
+      assert.equal(
+        reached,
+        true,
+        'the actual common transcript observer ran synchronously',
+      );
+      // A retired reply may consume its own received terminal, but cannot
+      // complete or overwrite the successor. Stop/restart permits no old writes.
+      const afterPacketExpected =
+        mode === 'typed successor'
+          ? {
+              ...afterObserver,
+              retiredReplyPending: false,
+              ownedTimers: afterObserver.ownedTimers - 1,
+            }
+          : afterObserver;
+      assert.deepEqual(packetState(h), afterPacketExpected);
+      await h.controller.toolQueue;
+      await turnOfEventLoop();
+      if (restart) await restart;
+      assertOldRemainderAbsent(h, observed);
+
+      let successorSocket;
+      if (mode === 'typed successor') {
+        assert.equal(typedAccepted, true);
+        assert.equal(
+          h.controller.epoch,
+          before.epoch,
+          'typed replacement shares the socket epoch',
+        );
+        assert.ok(h.controller.inputGeneration > before.inputGeneration);
+        assert.ok(h.controller.turn > before.turn);
+        assert.deepEqual(packetState(h), afterPacketExpected);
+        assert.equal(
+          h.controller.typedIntent.text,
+          'Zoom in for the typed successor',
+        );
+        assert.equal(h.controller.replyPending, true);
+        assert.equal(h.controller.retiredReplyPending, false);
+        assert.equal(oldAudio.closed, false);
+        const typedMessages = oldSocket.sent.filter((message) =>
+          message.clientContent?.turns?.some((turn) =>
+            turn.parts?.some(
+              (part) => part.text === 'Zoom in for the typed successor',
+            ),
+          ),
+        );
+        assert.equal(typedMessages.length, 1);
+        // The received packet already carried the old terminal. No extra
+        // provider boundary may be invented before testing the actual successor.
+        assert.equal(h.controller.retiredBoundaryWait, null);
+        assert.equal(h.controller.cancelledCalls.has(OLD_CALL), true);
+        assert.equal(h.controller.replyPending, true);
+        assert.equal(h.controller.completedTurns, 0);
+        assert.deepEqual(completions(h), []);
+        successorSocket = oldSocket;
+      } else {
+        assert.equal(oldSocket.closed, true);
+        assert.equal(oldAudio.closed, true);
+        assert.equal(h.controller.narration.state().tools, 0);
+        assert.equal(h.controller.narration.state().pendingTimers, 0);
+        assert.equal(h.clock.timers.size, 0);
+        if (mode === 'Stop') {
+          assert.equal(h.session.state, 'idle');
+          successorSocket = await h.start();
+        } else {
+          assert.equal(h.session.state, 'listening');
+          assert.equal(h.sockets.length, 2);
+          assert.equal(h.audios.length, 2);
+          assert.notEqual(h.audios[1], oldAudio);
+          assert.equal(h.audios[1].closed, false);
+          assert.equal(h.audios[1].pending, false);
+          successorSocket = h.sockets[1];
+        }
+        h.activity(successorSocket);
+      }
+      await h.tool('owned-after-packet-cancel', successorSocket);
+      assertSuccessfulZoom(
+        h,
+        successorSocket,
+        'owned-after-packet-cancel',
+        1000,
+      );
+      assert.equal(h.state.zooms.length, 1);
+      assert.equal(h.runnerCalls.length, 1);
+      assert.equal(
+        h.outputs(successorSocket).some((output) => output.id === OLD_CALL),
+        false,
+      );
+      h.complete(successorSocket);
+      assert.equal(completions(h).length, 1);
+      assert.equal(h.controller.narration.state().tools, 0);
+      assert.equal(h.controller.narration.state().pendingTimers, 0);
+    },
+  );
+}
+
+test(
+  'ordinary coalesced packet plays and executes once, then completes only after its post-tool reply',
+  options,
+  async (t) => {
+    const h = nativeIntegrationFixture(t);
+    const observed = observePacketEffects(h);
+    const ws = await h.start();
+    h.activity(ws);
+    ws.message(coalescedPacket('ordinary-coalesced'));
+    assert.equal(
+      h.controller.completedTurns,
+      1,
+      'first generation terminal is counted once',
+    );
+    assert.equal(h.controller.pendingTools, 1);
+    assert.deepEqual(
+      observed.played.map(({ data }) => data),
+      [OLD_PCM],
+    );
+    assert.equal(observed.played[0].audio, h.audios[0]);
+    assert.deepEqual(completions(h), [], 'tool and playback are still pending');
+    await h.controller.toolQueue;
+    assertSuccessfulZoom(h, ws, 'ordinary-coalesced', 1000);
+    assert.equal(h.controller.pendingTools, 0);
+    assert.equal(observed.narration.toolStarted, 1);
+    assert.equal(observed.narration.toolFinished, 1);
+    assert.equal(h.controller.narration.state().tools, 0);
+    h.audios[0].drain();
+    assert.equal(
+      h.controller.modelComplete,
+      false,
+      'function response waits for the post-tool generation',
+    );
+    assert.equal(h.controller.completedTurns, 1);
+    assert.deepEqual(
+      completions(h),
+      [],
+      'draining first-generation PCM cannot finish the tool reply',
+    );
+
+    // The accepted contract has two generations: the function response prompts
+    // a fresh model reply. This boundary is intentional, not a stale-packet fix.
+    ws.message({
+      serverContent: {
+        outputTranscription: { text: 'The requested zoom is complete.' },
+        modelTurn: {
+          parts: [
+            {
+              inlineData: {
+                data: POST_TOOL_PCM,
+                mimeType: 'audio/pcm;rate=24000',
+              },
+            },
+          ],
+        },
+        turnComplete: true,
+      },
+    });
+    assert.equal(h.controller.completedTurns, 2);
+    assert.deepEqual(
+      observed.played.map(({ data }) => data),
+      [OLD_PCM, POST_TOOL_PCM],
+    );
+    assert.deepEqual(
+      completions(h),
+      [],
+      'post-tool playback must drain before completion',
+    );
+    h.audios[0].drain();
+    assert.equal(completions(h).length, 1);
+    assert.equal(completions(h)[0].status, 'completed');
+    assert.equal(completions(h)[0].spoken, true);
+    assert.equal(completions(h)[0].audioDrained, true);
+    assert.equal(h.controller.pendingCompletionStatus, null);
+    assert.equal(h.controller.narration.state().tools, 0);
+    assert.equal(h.controller.narration.state().pendingTimers, 0);
+    assert.equal(h.clock.timers.size, 0);
+    assert.equal(observed.narration.audible, 2);
+    assert.equal(h.runnerCalls.length, 1);
+    assert.equal(h.state.zooms.length, 1);
+    assert.equal(h.outputs(ws).length, 1);
+    h.audios[0].drain();
+    assert.equal(
+      completions(h).length,
+      1,
+      'a duplicate device drain cannot complete twice',
+    );
+  },
+);
+
+// Real native message-type fields are separate packets here; no extra old
+// completion is inserted before the accepted successor.
+const BOUNDARY_OLD = 'Prior reply caption.';
+const BOUNDARY_NEXT = 'Zoom in for the typed successor';
+const boundaryZoomCall = (id) => ({
+  toolCall: {
+    functionCalls: [
+      {
+        id,
+        name: 'adjust_camera_zoom',
+        args: { direction: 'in', amount: 'little' },
+      },
+    ],
+  },
+});
+function boundarySnapshot(h) {
+  const c = h.controller;
+  return {
+    retiredReplyPending: c.retiredReplyPending,
+    retiredBoundaryWait: Boolean(c.retiredBoundaryWait),
+    replyPending: c.replyPending,
+    typedText: c.typedIntent?.text ?? null,
+    completions: h.events.filter((event) => event.type === 'completion').length,
+  };
+}
+
+for (const mode of [
+  'partial assistant transcript',
+  'input transcript',
+  'interruption event',
+  'listening event',
+  'final assistant transcript control',
+]) {
+  test(
+    `received native terminal preserves typed successor after ${mode}`,
+    { concurrency: false, timeout: 5000 },
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      const ws = await h.start();
+      h.activity(ws);
+      let oldDispatch, gate;
+      const interruptionMode =
+        mode === 'interruption event' || mode === 'listening event';
+      if (interruptionMode) {
+        h.session.sendText('Prior zoom request');
+        gate = h.holdResult('already-committed-old-tool');
+        oldDispatch = h.tool('already-committed-old-tool', ws);
+        await gate.ready;
+      } else if (mode === 'input transcript') {
+        ws.message({
+          serverContent: {
+            outputTranscription: { text: 'Previously emitted output' },
+          },
+        });
+      }
+      let entered = 0,
+        accepted;
+      const remove = h.session.subscribe((event) => {
+        if (entered) return;
+        const matches =
+          mode === 'interruption event'
+            ? event.type === 'interruption' && event.reason === 'user-speech'
+            : mode === 'listening event'
+              ? event.type === 'state' && event.state === 'listening'
+              : mode === 'input transcript'
+                ? event.type === 'transcript' &&
+                  event.role === 'user' &&
+                  event.text === 'Old input caption'
+                : event.type === 'transcript' &&
+                  event.role === 'assistant' &&
+                  event.text === BOUNDARY_OLD &&
+                  event.final ===
+                    (mode === 'final assistant transcript control');
+        if (!matches) return;
+        entered++;
+        accepted = h.session.sendText(BOUNDARY_NEXT);
+      });
+      if (interruptionMode)
+        ws.message({
+          serverContent: { interrupted: true, turnComplete: true },
+        });
+      else
+        ws.message({
+          serverContent: {
+            ...(mode === 'input transcript'
+              ? { inputTranscription: { text: 'Old input caption' } }
+              : {}),
+            outputTranscription: { text: BOUNDARY_OLD },
+            turnComplete: true,
+          },
+        });
+      remove();
+      if (oldDispatch) {
+        await oldDispatch;
+        gate.release();
+      }
+      await turnOfEventLoop();
+      const afterPacket = boundarySnapshot(h);
+      const beforeSuccessorHeight = h.state.height;
+      // No extra synthetic old boundary. This is the next reply to the accepted text.
+      ws.message({
+        serverContent: {
+          outputTranscription: { text: 'Handling your new zoom.' },
+        },
+      });
+      ws.message(boundaryZoomCall('typed-successor-call'));
+      await h.controller.toolQueue;
+      await turnOfEventLoop();
+      ws.message({ serverContent: { turnComplete: true } });
+      const afterSuccessor = boundarySnapshot(h);
+      assert.equal(entered, 1);
+      assert.equal(accepted, true);
+      assert.equal(
+        afterPacket.retiredReplyPending,
+        false,
+        'received old terminal must settle its retirement',
+      );
+      assert.equal(afterPacket.retiredBoundaryWait, false);
+      assert.equal(afterPacket.typedText, BOUNDARY_NEXT);
+      assert.equal(
+        h.runnerCalls.filter((x) => x.options.callId === 'typed-successor-call')
+          .length,
+        1,
+        'accepted typed successor must reach the actual runner',
+      );
+      assert.equal(h.state.height, beforeSuccessorHeight * 0.75);
+      assert.equal(afterSuccessor.completions, 1);
+      assert.equal(afterSuccessor.replyPending, false);
+      assert.equal(
+        h.controller.cancelledCalls.has('typed-successor-call'),
+        false,
+      );
+    },
+  );
+}
+
+for (const terminalAlreadyApplied of [false, true]) {
+  test(
+    `typed reentry retains a genuinely pending boundary when terminal already applied is ${terminalAlreadyApplied}`,
+    options,
+    async (t) => {
+      const h = nativeIntegrationFixture(t);
+      const ws = await h.start();
+      h.activity(ws);
+      let entered = false;
+      const remove = h.session.subscribe((event) => {
+        if (
+          entered ||
+          event.type !== 'transcript' ||
+          event.role !== 'assistant' ||
+          event.text !== 'Boundary control' ||
+          event.final !== terminalAlreadyApplied
+        )
+          return;
+        entered = true;
+        assert.equal(h.session.sendText('First typed replacement'), true);
+        if (terminalAlreadyApplied)
+          assert.equal(h.session.sendText('Second typed replacement'), true);
+      });
+      ws.message({
+        serverContent: {
+          outputTranscription: { text: 'Boundary control' },
+          ...(terminalAlreadyApplied ? { turnComplete: true } : {}),
+        },
+      });
+      remove();
+      assert.equal(entered, true);
+      // With no old terminal received, or when that terminal was consumed
+      // before the observer, a real predecessor boundary is still outstanding.
+      assert.equal(h.controller.retiredReplyPending, true);
+      assert.ok(h.controller.retiredBoundaryWait);
+      assert.equal(completions(h).length, 0);
+      assert.equal(h.runnerCalls.length, 0);
+      ws.message({ serverContent: { turnComplete: true } });
+      assert.equal(h.controller.retiredReplyPending, false);
+      assert.equal(h.controller.retiredBoundaryWait, null);
+      await h.tool('after-real-pending-boundary', ws);
+      assertSuccessfulZoom(h, ws, 'after-real-pending-boundary', 1000);
+      h.complete(ws);
+      assert.equal(completions(h).length, 1);
+    },
+  );
+}

src/voice/gevActions.js

@@ -1,6 +1,5 @@
 import {
   layerSnapshot,
-  layerSnapshots,
   feedProvenanceEnvelope,
 } from '../data/layerSnapshot.js';
 import { readLayerLifecycleSummary } from './layerSummary.js';
@@ -27,7 +26,6 @@ import {
   isContextRecordActive,
 } from '../data/contextStore.js';
 import { CCTV_FOCUS_RESULT } from '../layers/cctv/index.js';
-import { contextModeWord } from '../contextModePolicy.js';
 import {
   createAnalystEngine,
   normalizeAnalystSpec,
@@ -48,6 +46,12 @@ import { unavailablePlaceSearch } from '../search/placeSearch.js';
 import * as defaultAnnotationResolver from '../annotations/annotationResolver.js';
 import { normalizeRadioCountryInput } from '../data/radioCountry.js';
 import { TR3B_CLASS } from '../data/tr3bRegistry.js';
+import {
+  getWorldPacket,
+  withContextModeVocabulary,
+  activeContactsWindow,
+  TRACKABLE_FAMILIES,
+} from '../agent/worldPacket.js';
 
 const ALLOWED_STYLES = new Set([
   'normal',
@@ -119,64 +123,6 @@ const CONTEXT_MODE_ALIASES = new Map([
   ['space-missions', 'space-missions'],
   ['missions', 'space-missions'],
 ]);
-/**
- * Every model-readable field that carries a context-mode id, and what an
- * absent value means for each.
- *
- * `mode` always names a mode, so nothing is 'off'. `entering` and `priorMode`
- * are absent when there is no such mode at all — calling those 'off' would
- * assert a state that does not exist.
- */
-const CONTEXT_MODE_RESULT_FIELDS = Object.freeze([
-  { field: 'mode', emptyAs: 'off' },
-  { field: 'entering', emptyAs: null },
-  { field: 'priorMode', emptyAs: null },
-]);
-
-/** Nested results that are themselves context-mode payloads the model reads. */
-const NESTED_CONTEXT_RESULT_FIELDS = Object.freeze([
-  'context',
-  'contextRollback',
-]);
-
-/**
- * Report a context-mode payload in the tools' own vocabulary.
- *
- * `set_context_mode` accepts 'contacts' while the mode's internal id is
- * 'flights'. Reporting the internal id back made the model read
- * `mode:'flights'` as "Contacts is off" and refuse to answer from the Contacts
- * window counts sitting in the very same payload (owner field session
- * 2026-08-21). Secondary fields and nested transition/rollback results are
- * translated too — one leaked internal id is enough to recreate the confusion,
- * and a rollback result is exactly what the model reads when something went
- * wrong. Each internal id is kept alongside as `<field>Internal` for anything
- * reasoning about layers.
- * @param {object|null|undefined} state Any payload carrying context-mode fields.
- * @returns {object|null|undefined} The same payload, modes translated.
- */
-function withContextModeVocabulary(state) {
-  if (!state || typeof state !== 'object') return state;
-  let out = state;
-  const mutable = () => {
-    if (out === state) out = { ...state };
-    return out;
-  };
-  for (const { field, emptyAs } of CONTEXT_MODE_RESULT_FIELDS) {
-    if (!(field in state)) continue;
-    const internal = state[field] ?? null;
-    const target = mutable();
-    target[field] = contextModeWord(internal, { emptyAs });
-    target[`${field}Internal`] = internal;
-  }
-  for (const field of NESTED_CONTEXT_RESULT_FIELDS) {
-    const nested = state[field];
-    if (!nested || typeof nested !== 'object') continue;
-    const translated = withContextModeVocabulary(nested);
-    if (translated !== nested) mutable()[field] = translated;
-  }
-  return out;
-}
-
 const COCKPIT_ACTION_ALIASES = new Map([
   ['next', 'next'],
   ['previous', 'previous'],
@@ -246,14 +192,6 @@ const STACK_ALIASES = new Map([
   ['road map', 'osm'],
 ]);
 
-/** Search order for track_entity across entity layer families. */
-const TRACKABLE_FAMILIES = [
-  { layerId: 'flights', kind: 'aircraft' },
-  { layerId: 'military', kind: 'aircraft' },
-  { layerId: 'ais-live-vessels', kind: 'vessel' },
-  { layerId: 'satellites', kind: 'satellite' },
-];
-
 const FRAME_TARGETS = new Map([
   ['flights', 'flights'],
   ['planes', 'flights'],
@@ -2553,26 +2491,6 @@ function runManagedVoiceNavigation(
   };
 }
 
-/** Gathers tracked/selected entities across layer families for read-back. */
-function collectTrackedEntities(dataManager) {
-  const tracked = [];
-  for (const family of TRACKABLE_FAMILIES) {
-    const module = dataManager.layers.get(family.layerId)?.module;
-    if (!module) continue;
-    try {
-      const info =
-        family.kind === 'vessel'
-          ? module.getSelectedInfo?.()
-          : module.getTrackedInfo?.();
-      if (info)
-        tracked.push({ kind: family.kind, layerId: family.layerId, ...info });
-    } catch {
-      // layer not ready
-    }
-  }
-  return tracked;
-}
-
 export async function getBasemapLabelContext(
   viewer,
   service = defaultGeospatial,
@@ -3210,60 +3128,12 @@ function getCurrentViewState(
   dataManager,
   sceneDirector = null,
 ) {
-  const cartographic = Cesium.Cartographic.fromCartesian(
-    viewer.camera.positionWC,
-  );
-  return {
-    ok: true,
-    action: 'get_current_view_state',
-    camera: {
-      latitude: Cesium.Math.toDegrees(cartographic.latitude),
-      longitude: Cesium.Math.toDegrees(cartographic.longitude),
-      heightM: cartographic.height,
-    },
-    style: styleManager.activeStyle || 'normal',
-    context:
-      typeof styleManager.getContextModeState === 'function'
-        ? {
-            ...withContextModeVocabulary(styleManager.getContextModeState()),
-            // The numbers on the operator's Contacts panel, so a window/count
-            // question can be answered from what they are looking at.
-            ...(activeContactsWindow(dataManager)
-              ? { contactsWindow: activeContactsWindow(dataManager) }
-              : {}),
-          }
-        : null,
-    cockpit:
-      typeof styleManager.getCockpitState === 'function'
-        ? styleManager.getCockpitState()
-        : null,
-    controls:
-      typeof styleManager.getControlState === 'function'
-        ? styleManager.getControlState()
-        : null,
-    scenePlayback: sceneDirector?.getPlaybackStatus?.() || null,
-    tracked: collectTrackedEntities(dataManager),
-    // Enabled layers only: the full registry cost ~1k tokens per call and
-    // the model only reasons about what is on.
-    disabledLayerCount: dataManager.getAll().filter((layer) => !layer.enabled)
-      .length,
-    layers: dataManager
-      .getAll()
-      .filter((layer) => layer.enabled)
-      .map((layer) => ({
-        id: layer.id,
-        name: layer.name,
-        enabled: layer.enabled,
-        count: layer.stats?.count || 0,
-        error: layer.stats?.error || null,
-        feedState: layerSnapshot(layer).feedState,
-        source: layerSnapshot(layer).source,
-        lastUpdate: layerSnapshot(layer).lastUpdate,
-      })),
-    feedProvenance: feedProvenanceEnvelope(
-      layerSnapshots(dataManager.getAll()).filter((layer) => layer.enabled),
-    ),
-  };
+  return getWorldPacket({
+    viewer,
+    styleManager,
+    dataManager,
+    sceneDirector,
+  });
 }
 
 async function getEntityContext(
@@ -4635,23 +4505,6 @@ function clampNumber(value, min, max, fallback) {
  * ("which of those is closest?") scoped to the session.
  */
 
-/**
- * The Contacts panel's own counts, or null when Contacts has no subject.
- * Read through the awareness snapshot the panel renders, so the two cannot
- * diverge no matter which surface asks.
- * @returns {object|null} Panel-equivalent window counts.
- */
-function activeContactsWindow(dataManager) {
-  try {
-    const layer = dataManager?.layers?.get('military-awareness')?.module;
-    return (
-      layer?.contactsWindowFromSnapshot?.(layer.getContextSnapshot?.()) ?? null
-    );
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Most records one layer hands a single query. Above every loaded feed seen
  * so far (flights ~8k, vessels ~12k, a 24 h global FIRMS day ~160k), so

src/voice/gevRealtime.js

@@ -61,10 +61,8 @@ export function initGevVoiceCommands(options) {
   });
   deixis.imageFrame = () => commands.retainedImageFrame?.() || null;
   deixis.onPointerUsed = () => commands.announcePointer?.();
-  commands.session?.signal?.addEventListener(
-    'abort',
-    () => pointer?.destroy(),
-    { once: true },
-  );
+  const lifetime = commands.signal ?? commands.session?.signal;
+  lifetime?.addEventListener('abort', () => pointer?.destroy(), { once: true });
+  if (lifetime?.aborted) pointer?.destroy();
   return commands;
 }

src/voice/pointerContext.js

@@ -182,6 +182,63 @@ export function pointerChip(snapshot) {
   };
 }
 
+/** Dedupe key of the clearing pointer_context item. */
+export const POINTER_NONE_KEY = 'none';
+
+/**
+ * The voice-card event for a turn's pointer: a gesture reveals its target at
+ * once; open-mic and typed turns reveal it only through announcePointer.
+ * @param {object|null} snapshot
+ * @param {boolean} gesture
+ * @returns {{announced: object|null, pointer: object|null}}
+ */
+export function pointerTurnEvent(snapshot, gesture) {
+  const chip = gesture ? pointerChip(snapshot) : null;
+  return chip
+    ? { announced: snapshot, pointer: { ...chip, screenPx: snapshot.screenPx } }
+    : { announced: null, pointer: null };
+}
+
+/**
+ * The pointer_context item a turn should send, or null when there is nothing
+ * new. Without a gesture the model learns only what kind of thing is pointed
+ * at, never which. Losing a sent pointer produces one clearing item.
+ * @param {object|null} snapshot
+ * @param {{at: string, gesture: boolean, sentKey: string|null}} turn
+ * @returns {{item: object, key: string}|null}
+ */
+export function pointerTurnContext(snapshot, { at, gesture, sentKey }) {
+  const chip = pointerChip(snapshot);
+  const item = !chip
+    ? sentKey && sentKey !== POINTER_NONE_KEY
+      ? { type: 'pointer_context', at, target: 'none' }
+      : null
+    : gesture
+      ? pointerContextItem(snapshot)
+      : {
+          type: 'pointer_context',
+          at,
+          pointing: snapshot.entity?.kind || 'ground',
+        };
+  if (!item) return null;
+  const { at: _at, ...content } = item;
+  const key = chip ? JSON.stringify(content) : POINTER_NONE_KEY;
+  return key === sentKey ? null : { item, key };
+}
+
+/**
+ * The voice-card event revealing a pointer a tool resolved, once per snapshot.
+ * @param {object|null} snapshot
+ * @param {object|null} announced Snapshot already shown.
+ * @returns {object|null}
+ */
+export function pointerAnnouncement(snapshot, announced) {
+  const chip = pointerChip(snapshot);
+  return chip && snapshot !== announced
+    ? { ...chip, screenPx: snapshot.screenPx }
+    : null;
+}
+
 /**
  * Track the pointer over one element (the globe canvas).
  * @param {object} options
@@ -330,7 +387,14 @@ export function createPointerTracker({
      * (open mic only when it moved recently: `recentMs`). The result becomes
      * the turn's referent (null when stale).
      */
-    beginTurn(at, { recentMs = POINTER_FRESH_MS } = {}) {
+    beginTurn(at, { recentMs = POINTER_FRESH_MS, capturedSnapshot } = {}) {
+      // Delayed admitted audio keeps its capture's pointer without replacing a
+      // newer physical hold. Undefined preserves existing caller behavior.
+      if (capturedSnapshot !== undefined) {
+        const snapshot = destroyed ? { fresh: false, at } : capturedSnapshot;
+        active = snapshot?.fresh ? snapshot : null;
+        return snapshot;
+      }
       const reuse =
         at !== 'text' && held && now() - held.heldAt <= POINTER_HOLD_MS;
       const snapshot = reuse ? held.snapshot : capture(at, { recentMs });

src/voice/pointerContext.test.mjs

@@ -6,8 +6,13 @@ import {
   POINTER_HOLD_MS,
   buildPointerSnapshot,
   createPointerTracker,
+  POINTER_NONE_KEY,
   formatPointerContext,
+  pointerAnnouncement,
   pointerChip,
+  pointerContextItem,
+  pointerTurnContext,
+  pointerTurnEvent,
 } from './pointerContext.js';
 
 function harness({ pick } = {}) {
@@ -151,6 +156,51 @@ test('destroy removes listeners and ignores later moves', () => {
   assert.equal(h.tracker.capture('keydown').fresh, false);
 });
 
+test('delayed speech uses its released capture without replacing a newer physical hold', () => {
+  const h = harness();
+  h.move(700, 250);
+  const capturedA = h.tracker.hold();
+  h.tracker.releaseHold();
+  h.move(200, 100);
+  h.tracker.beginTurn('speech_start', { capturedSnapshot: capturedA });
+  assert.equal(h.tracker.activeSnapshot(), capturedA);
+  const heldB = h.tracker.hold();
+  h.tracker.beginTurn('speech_start', { capturedSnapshot: capturedA });
+  assert.equal(h.tracker.activeSnapshot(), capturedA);
+  assert.equal(h.tracker.isHeld(), true);
+  assert.equal(h.tracker.beginTurn('speech_start'), heldB);
+  h.tracker.destroy();
+});
+
+test('explicit stale captures clear the referent while a silent hold leaves it alone', () => {
+  const h = harness();
+  h.move(700, 250);
+  const current = h.tracker.beginTurn('text');
+  h.move(200, 100);
+  h.tracker.hold();
+  h.tracker.releaseHold();
+  assert.equal(h.tracker.activeSnapshot(), current);
+  for (const capturedSnapshot of [null, { fresh: false, at: 'keydown' }]) {
+    h.tracker.beginTurn('text');
+    h.tracker.beginTurn('speech_start', { capturedSnapshot });
+    assert.equal(h.tracker.activeSnapshot(), null);
+  }
+  h.tracker.destroy();
+});
+
+test('a capture arriving after destruction cannot restore an active referent', () => {
+  const h = harness();
+  h.move(700, 250);
+  const capturedSnapshot = h.tracker.hold();
+  assert.equal(capturedSnapshot.fresh, true);
+  h.tracker.destroy();
+  const result = h.tracker.beginTurn('speech_start', { capturedSnapshot });
+  assert.equal(result.fresh, false);
+  assert.equal(h.tracker.activeSnapshot(), null);
+  assert.equal(h.tracker.isHeld(), false);
+  assert.equal(h.tracker.beginTurn('speech_start').fresh, false);
+});
+
 test('format: the model item is compact inert JSON; labels are bounded data', () => {
   const snapshot = buildPointerSnapshot({
     at: 'speech_start',
@@ -182,3 +232,65 @@ test('chip: "this" names an entity, "here" gives the ground coordinate', () => {
   assert.deepEqual(pointerChip(ground), { kind: 'here', label: '30.27, -97.74' });
   assert.equal(pointerChip(null), null);
 });
+
+test('pointer turn helpers reveal gesture targets, describe implicit ones by kind and dedupe repeats', () => {
+  const snapshot = {
+    fresh: true,
+    at: 'keydown',
+    entity: { kind: 'aircraft', layerId: 'flights', label: 'UAL1' },
+    lat: 10,
+    lon: 20,
+    screen: { x: 5, y: 6 },
+    screenPx: { x: 5, y: 6 },
+  };
+  const shown = pointerTurnEvent(snapshot, true);
+  assert.equal(shown.announced, snapshot);
+  assert.deepEqual(shown.pointer, {
+    kind: 'this',
+    label: 'UAL1',
+    screenPx: { x: 5, y: 6 },
+  });
+  assert.deepEqual(pointerTurnEvent(snapshot, false), {
+    announced: null,
+    pointer: null,
+  });
+
+  const gesture = pointerTurnContext(snapshot, {
+    at: 'keydown',
+    gesture: true,
+    sentKey: null,
+  });
+  assert.deepEqual(gesture.item, pointerContextItem(snapshot));
+  assert.equal(
+    pointerTurnContext(snapshot, {
+      at: 'keydown',
+      gesture: true,
+      sentKey: gesture.key,
+    }),
+    null,
+  );
+  assert.deepEqual(
+    pointerTurnContext(snapshot, { at: 'text', gesture: false, sentKey: null })
+      .item,
+    { type: 'pointer_context', at: 'text', pointing: 'aircraft' },
+  );
+
+  const cleared = pointerTurnContext(null, {
+    at: 'text',
+    gesture: false,
+    sentKey: gesture.key,
+  });
+  assert.deepEqual(cleared, {
+    item: { type: 'pointer_context', at: 'text', target: 'none' },
+    key: POINTER_NONE_KEY,
+  });
+  for (const sentKey of [null, POINTER_NONE_KEY])
+    assert.equal(
+      pointerTurnContext(null, { at: 'text', gesture: false, sentKey }),
+      null,
+    );
+
+  assert.deepEqual(pointerAnnouncement(snapshot, null), shown.pointer);
+  assert.equal(pointerAnnouncement(snapshot, snapshot), null);
+  assert.equal(pointerAnnouncement(null, null), null);
+});

src/voice/providerCapabilities.js

@@ -0,0 +1,21 @@
+export const VOICE_PROVIDERS = Object.freeze({
+  openai: Object.freeze({ label: 'OpenAI' }), // i18n-ignore: provider product name
+  gemini: Object.freeze({ label: 'Gemini' }), // i18n-ignore: provider product name
+});
+
+/** Optional providers require an explicit host opt-in and an available factory. */
+export function supportedVoiceProviders(
+  requested = ['openai'],
+  factories = {},
+) {
+  if (!Array.isArray(requested))
+    throw new TypeError('supportedProviders must be an array');
+  const selected = [...new Set(requested)].filter(
+    (name) =>
+      Object.hasOwn(VOICE_PROVIDERS, name) &&
+      typeof factories[name] === 'function',
+  );
+  if (!selected.length)
+    throw new Error('No supported voice provider is configured');
+  return Object.freeze(selected);
+}

src/voice/providerCommands.js

@@ -0,0 +1,161 @@
+import { supportedVoiceProviders } from './providerCapabilities.js';
+
+const STORAGE_KEY = 'gev.voice.provider';
+
+export function readVoiceProvider(storage, supported = ['openai', 'gemini']) {
+  let saved;
+  try {
+    saved = (storage ?? globalThis.localStorage)?.getItem(STORAGE_KEY);
+  } catch {
+    /* Storage is optional. */
+  }
+  return supported.includes(saved)
+    ? saved
+    : supported.includes('openai')
+      ? 'openai'
+      : supported[0];
+}
+
+/** Keep one public controller identity while replacing each provider's lifetime. */
+export function createProviderCommands(options, { bind, factories, storage }) {
+  const supportedProviders = supportedVoiceProviders(
+    options.supportedProviders ?? Object.keys(factories),
+    factories,
+  );
+  window.__gevVoiceCommands?.stop?.({ removeUi: true });
+  let provider = readVoiceProvider(storage, supportedProviders);
+  let current;
+  let disposed = false;
+  const lifetime = new AbortController();
+  let mountGeneration = 0;
+  let voiceEnabled = false;
+  const stored = () => {
+    try {
+      return storage ?? globalThis.localStorage;
+    } catch {
+      return null;
+    }
+  };
+  const stop = (settings = {}) => {
+    if (disposed) return;
+    voiceEnabled = false;
+    if (settings.removeUi) {
+      disposed = true;
+      options.signal?.removeEventListener('abort', destroy);
+    }
+    try {
+      current?.session.stop(settings);
+    } finally {
+      if (settings.removeUi) {
+        lifetime.abort();
+        options.runner.dispose?.();
+      }
+    }
+  };
+  const destroy = () => stop({ removeUi: true });
+  const selectProvider = (next) => {
+    if (disposed || !supportedProviders.includes(next) || next === provider)
+      return false;
+    const resume = voiceEnabled && current.session.isActive();
+    // Carry the input mode, never a held key, microphone or conversation.
+    const pushToTalk = Boolean(
+      current.session.adapter.getStartOptions?.().pushToTalk,
+    );
+    const generation = ++mountGeneration;
+    voiceEnabled = false;
+    current.session.destroy();
+    // Disposal suppresses the retired adapter's idle event. Clear the shared
+    // conversation explicitly before the new mount can use these owners.
+    if (disposed || generation !== mountGeneration) return false;
+    options.pointer?.clear();
+    options.referents?.clear();
+    options.runner.resetConversation?.();
+    if (disposed || generation !== mountGeneration) return false;
+    provider = next;
+    try {
+      stored()?.setItem(STORAGE_KEY, provider);
+    } catch {
+      /* Storage is optional. */
+    }
+    mount();
+    if (resume && !disposed && provider === next)
+      void current.session.start({ pushToTalk });
+    globalThis.document?.getElementById('gev-voice-provider')?.focus();
+    return true;
+  };
+
+  const handleSessionEvent = (event) => {
+    if (event?.type === 'state' && event.state === 'connecting')
+      voiceEnabled = true;
+    if (event?.type === 'state' && ['idle', 'error'].includes(event.state)) {
+      voiceEnabled = false;
+    }
+    // The host still observes the mounted provider's neutral session events.
+    options.onSessionEvent?.(event);
+  };
+
+  const sendTextCommand = (text) => {
+    if (disposed) return false;
+    return current.session.sendText(text);
+  };
+
+  const api = {
+    // The shared action surface is independent of an active voice connection.
+    runner: options.runner,
+    supportedProviders,
+    signal: lifetime.signal,
+    get provider() {
+      return provider;
+    },
+    get session() {
+      return current?.session;
+    },
+    get status() {
+      return current?.status ?? current?.session.state ?? 'idle';
+    },
+    get state() {
+      return current?.session.state ?? 'idle';
+    },
+    get disposed() {
+      return disposed;
+    },
+    start: (settings) => !disposed && current.session.start(settings),
+    stop,
+    destroy,
+    isActive: () => !disposed && current.session.isActive(),
+    sendTextCommand,
+    sendText: sendTextCommand,
+    notifyMapEvent: (event) => !disposed && current.session.sendMapEvent(event),
+  };
+  // Existing diagnostic and controller accessors continue to reflect the active provider.
+  const facade = new Proxy(api, {
+    get(target, name, receiver) {
+      if (Reflect.has(target, name)) return Reflect.get(target, name, receiver);
+      const value = current?.[name];
+      return typeof value === 'function' ? value.bind(current) : value;
+    },
+  });
+  function mount() {
+    voiceEnabled = false;
+    const generation = ++mountGeneration;
+    current = bind({
+      ...options,
+      signal: lifetime.signal,
+      resetExisting: false,
+      disposeRunner: false,
+      provider,
+      supportedProviders,
+      onProviderChange: selectProvider,
+      onSessionEvent: (event) => {
+        if (!disposed && generation === mountGeneration)
+          handleSessionEvent(event);
+      },
+      createSession: factories[provider],
+    });
+    window.__gevVoiceCommands = facade;
+  }
+  mount();
+  options.signal?.addEventListener('abort', destroy, { once: true });
+  if (options.signal?.aborted) destroy();
+  return facade;
+}

src/voice/providerCommands.test.mjs

@@ -0,0 +1,888 @@
+// Imports intentionally target the candidate, never the immutable reference.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  createProviderCommands,
+  readVoiceProvider,
+} from './providerCommands.js';
+import { createVoiceCommands as bindVoiceCommands } from './sessionCommands.js';
+import { createVoiceCommands as createCommands } from './commands.js';
+import { createGevActionRunner } from './gevActions.js';
+import { createPointerTracker } from './pointerContext.js';
+import { createReferentRegistry } from './referents.js';
+import { describeUnsavedWork, t as translate } from '../i18n/index.js';
+
+const PROVIDER_KEY = 'gev.voice.provider';
+const settle = () => new Promise((resolve) => setImmediate(resolve));
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+
+// Listener counts observe the actual binder's registrations/removals.
+class Element extends EventTarget {
+  listeners = new Map();
+  attributes = new Map();
+  addEventListener(type, handler, options) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type).add(handler);
+    super.addEventListener(type, handler, options);
+  }
+  removeEventListener(type, handler, options) {
+    this.listeners.get(type)?.delete(handler);
+    super.removeEventListener(type, handler, options);
+  }
+  listenerCount(type) {
+    return this.listeners.get(type)?.size || 0;
+  }
+  setAttribute(name, value) {
+    this.attributes.set(name, String(value));
+  }
+  focus() {
+    this.focusCount = (this.focusCount || 0) + 1;
+  }
+}
+
+for (const custom of [false, true]) {
+  test(`public composition preserves the ${custom ? 'custom adapter' : 'default OpenAI adapter'} path`, async (t) => {
+    const prior = globalThis.window;
+    globalThis.window = new EventTarget();
+    let controls;
+    t.after(() => {
+      controls?.session.destroy();
+      globalThis.window = prior;
+    });
+    const ui = {
+      root: { dataset: {}, remove() {} },
+      button: new Element(),
+      status: {},
+      detail: {},
+      providerField: {},
+    };
+    let defaultCreated = 0;
+    let customCreated = 0;
+    const options = {
+      runner: async () => ({ ok: true }),
+      createControl: () => ui,
+      createController: ({ onSessionEvent }) => {
+        defaultCreated++;
+        return {
+          ui,
+          start({ pushToTalk }) {
+            this.pushToTalkMode = pushToTalk;
+            onSessionEvent({ type: 'state', state: 'listening' });
+          },
+          stop() {},
+          syncCostUi() {},
+          bindPushToTalkShortcut() {},
+          sendTextCommand: (text) => `default:${text}`,
+        };
+      },
+    };
+    if (custom) {
+      options.supportedProviders = ['gemini'];
+      options.createSession = ({ emit }) => {
+        customCreated++;
+        return {
+          capabilities: { pushToTalk: false },
+          start() {
+            emit({ type: 'state', state: 'listening' });
+          },
+          stop() {},
+          sendText: (text) => `custom:${text}`,
+          sendMapEvent: () => true,
+        };
+      };
+    }
+    controls = createCommands(options);
+    await controls.session.start({ pushToTalk: true });
+    assert.equal(defaultCreated, custom ? 0 : 1);
+    assert.equal(customCreated, custom ? 1 : 0);
+    assert.equal(
+      controls.session.sendText('test'),
+      `${custom ? 'custom' : 'default'}:test`,
+    );
+    assert.equal(ui.providerField.hidden, true);
+    assert.equal(ui.root.dataset.providerChoice, 'false');
+    if (!custom)
+      assert.deepEqual(controls.session.adapter.getStartOptions(), {
+        pushToTalk: true,
+      });
+  });
+}
+
+/** Real facade -> real binder -> real common session and real action runner.
+ * Adapters and passive UI/viewer boundaries are fixtures. Wrappers only count
+ * calls to real pointer/referent/conversation cleanup; they do not replace it.
+ */
+function compositionFixture(
+  t,
+  {
+    supportedProviders = ['openai', 'gemini'],
+    factoryProviders = ['openai', 'gemini'],
+    savedProvider = null,
+    storageDenied = false,
+    gateStarts = () => false,
+    onSessionEvent = () => {},
+  } = {},
+) {
+  const original = new Map(
+    ['window', 'document'].map((key) => [
+      key,
+      Object.getOwnPropertyDescriptor(globalThis, key),
+    ]),
+  );
+  const lifetime = new AbortController();
+  const views = [];
+  const instances = [];
+  const mounts = [];
+  const events = [];
+  const order = [];
+  const annotations = new Set();
+  const storageWrites = [];
+  const counters = { pointer: 0, referents: 0, conversation: 0, dispose: 0 };
+  const state = { height: 1000, zooms: 0, renders: 0 };
+  let facade;
+  let pointer;
+  globalThis.window = new EventTarget();
+  globalThis.document = {
+    getElementById: (id) =>
+      id === 'gev-voice-provider' ? views.at(-1)?.providerSelect : null,
+  };
+  t.after(async () => {
+    try {
+      facade?.destroy();
+      pointer?.destroy();
+      for (const instance of instances)
+        for (const gate of instance.gates) gate.resolve();
+      await Promise.allSettled(instances.flatMap((instance) => instance.jobs));
+    } finally {
+      for (const [key, descriptor] of original) {
+        if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+        else delete globalThis[key];
+      }
+    }
+  });
+
+  const canvas = new EventTarget();
+  Object.assign(canvas, { clientWidth: 800, clientHeight: 600 });
+  const position = { x: 6379137, y: 0, z: 0 };
+  const viewer = {
+    clock: { onTick: { addEventListener: () => () => {} } },
+    camera: {
+      positionWC: position,
+      positionCartographic: { height: state.height },
+      moveEnd: { addEventListener() {} },
+      cancelFlight() {},
+      zoomIn(metres) {
+        position.x -= metres;
+        state.height -= metres;
+        this.positionCartographic.height = state.height;
+        state.zooms++;
+      },
+      zoomOut(metres) {
+        position.x += metres;
+        state.height += metres;
+        this.positionCartographic.height = state.height;
+        state.zooms++;
+      },
+    },
+    scene: {
+      canvas,
+      requestRender() {
+        state.renders++;
+      },
+    },
+  };
+  const dataManager = { layers: new Map() };
+  pointer = createPointerTracker({ element: null, now: () => 1000 });
+  const referents = createReferentRegistry();
+  const runner = createGevActionRunner({
+    viewer,
+    dataManager,
+    styleManager: {},
+    deixis: { pointer, referents },
+  });
+  for (const [object, method, counter] of [
+    [pointer, 'clear', 'pointer'],
+    [referents, 'clear', 'referents'],
+    [runner, 'resetConversation', 'conversation'],
+    [runner, 'dispose', 'dispose'],
+  ]) {
+    const originalMethod = object[method];
+    object[method] = (...args) => {
+      counters[counter]++;
+      order.push(counter);
+      return originalMethod.apply(object, args);
+    };
+  }
+
+  const factories = Object.fromEntries(
+    factoryProviders.map((provider) => [
+      provider,
+      (hooks) => {
+        const id = instances.length;
+        let generation = 0;
+        const instance = {
+          id,
+          provider,
+          hooks,
+          starts: [],
+          stops: [],
+          jobs: [],
+          gates: [],
+          acquired: 0,
+          microphoneEnabled: false,
+          bound: 0,
+          input: { pushToTalk: false, held: false },
+          texts: [],
+          mapEvents: [],
+        };
+        instances.push(instance);
+        order.push(`factory:${id}`);
+        const adapter = {
+          identity: `${provider}:${id}`,
+          capabilities: {
+            pushToTalk: true,
+            costControls: provider === 'openai',
+          },
+          controller: {
+            providerDiagnostic() {
+              return this.session.adapter.identity;
+            },
+          },
+          start(settings = {}) {
+            const attempt = ++generation;
+            instance.starts.push({ ...settings });
+            instance.input.pushToTalk = Boolean(settings.pushToTalk);
+            hooks.emit({
+              type: 'state',
+              state: 'connecting',
+              detail: `adapter:${provider}`,
+            });
+            const job = (async () => {
+              if (attempt !== generation || hooks.signal.aborted) return;
+              if (gateStarts(instance)) {
+                const gate = deferred();
+                instance.gates.push(gate);
+                await gate.promise;
+              }
+              // Adapters own cancellation of their asynchronous acquisition.
+              if (attempt !== generation || hooks.signal.aborted) return;
+              instance.acquired++;
+              instance.microphoneEnabled =
+                !instance.input.pushToTalk || instance.input.held;
+              hooks.emit({
+                type: 'state',
+                state: 'listening',
+                detail: provider,
+              });
+            })();
+            instance.jobs.push(job);
+            return job;
+          },
+          stop(settings = {}) {
+            generation++;
+            instance.stops.push({ ...settings });
+            order.push(`stop:${id}`);
+            instance.input.pushToTalk = instance.input.held = false;
+            instance.microphoneEnabled = false;
+          },
+          getStartOptions: () => ({ pushToTalk: instance.input.pushToTalk }),
+          bindControls() {
+            instance.bound++;
+          },
+          sendText(text) {
+            instance.texts.push(text);
+            return `${provider}:${text}`;
+          },
+          sendMapEvent(event) {
+            instance.mapEvents.push(event);
+            return true;
+          },
+        };
+        instance.adapter = adapter;
+        return adapter;
+      },
+    ]),
+  );
+
+  function createControl() {
+    const id = views.length;
+    order.push(`control:${id}`);
+    const providerSelect = new Element();
+    providerSelect.ownerDocument = { createElement: () => ({}) };
+    providerSelect.replaceChildren = (...options) => {
+      providerSelect.options = options;
+    };
+    const view = {
+      root: {
+        dataset: {},
+        classList: { remove() {} },
+        removeCount: 0,
+        remove() {
+          this.removeCount++;
+          order.push(`remove:${id}`);
+        },
+      },
+      button: new Element(),
+      providerSelect,
+      providerField: {},
+      status: {},
+      detail: {},
+      errorDetail: {},
+      tierButton: {},
+      costValue: {},
+      helpDetail: {},
+      card: {},
+    };
+    views.push(view);
+    return view;
+  }
+  function passiveView() {
+    return {
+      events: [],
+      outlines: [],
+      destroyed: 0,
+      handle(event) {
+        this.events.push(event);
+      },
+      outline(event) {
+        this.outlines.push(event);
+      },
+      destroy() {
+        this.destroyed++;
+      },
+    };
+  }
+
+  facade = createProviderCommands(
+    {
+      runner,
+      pointer,
+      referents,
+      dataManager,
+      signal: lifetime.signal,
+      supportedProviders,
+      createControl,
+      createCard() {
+        const card = passiveView();
+        views.at(-1).cardView = card;
+        return card;
+      },
+      createReticle() {
+        const reticle = passiveView();
+        views.at(-1).reticle = reticle;
+        return reticle;
+      },
+      annotations: {
+        onOutlineEvent(callback) {
+          annotations.add(callback);
+          return () => annotations.delete(callback);
+        },
+      },
+      onSessionEvent(event) {
+        events.push(event);
+        onSessionEvent(event, facade);
+      },
+    },
+    {
+      factories,
+      storage: {
+        getItem() {
+          if (storageDenied) throw Error('Storage denied');
+          return savedProvider;
+        },
+        setItem(key, value) {
+          if (storageDenied) throw Error('Storage denied');
+          storageWrites.push([key, value]);
+          savedProvider = value;
+        },
+      },
+      bind(options) {
+        // Keep the real callback so stale-event suppression tests exercise the
+        // facade's mount generation as well as the common session's disposal.
+        const mount = { options, callback: options.onSessionEvent };
+        mounts.push(mount);
+        mount.controls = bindVoiceCommands(options);
+        return mount.controls;
+      },
+    },
+  );
+  return {
+    facade,
+    runner,
+    pointer,
+    referents,
+    lifetime,
+    instances,
+    views,
+    mounts,
+    events,
+    order,
+    annotations,
+    counters,
+    storageWrites,
+    state,
+    select(provider) {
+      const select = views.at(-1).providerSelect;
+      select.value = provider;
+      select.dispatchEvent(new Event('change'));
+    },
+    seedConversation() {
+      pointer.beginTurn('text', {
+        capturedSnapshot: { fresh: true, at: 'text' },
+      });
+      referents.recordResult('frame_overhead', {
+        ok: true,
+        display: { title: 'One aircraft' },
+        referents: [
+          { n: 1, id: 'aaa111', label: 'Fixture', layerId: 'flights' },
+        ],
+      });
+      assert.ok(pointer.activeSnapshot());
+      assert.equal(referents.list().length, 1);
+    },
+  };
+}
+
+test('provider preference uses only the supplied host capability list', () => {
+  const stored = (value) => ({ getItem: () => value });
+  assert.equal(readVoiceProvider(stored('gemini'), ['openai']), 'openai');
+  assert.equal(readVoiceProvider(stored('openai'), ['gemini']), 'gemini');
+  assert.equal(
+    readVoiceProvider(stored('unknown'), ['gemini', 'openai']),
+    'openai',
+  );
+  assert.equal(
+    readVoiceProvider(stored('gemini'), ['openai', 'gemini']),
+    'gemini',
+  );
+  assert.equal(
+    readVoiceProvider(
+      {
+        getItem() {
+          throw Error('denied');
+        },
+      },
+      ['gemini'],
+    ),
+    'gemini',
+  );
+});
+
+for (const scenario of [
+  {
+    title: 'OpenAI-only host ignores saved Gemini',
+    requested: ['openai'],
+    saved: 'gemini',
+    expected: ['openai'],
+    provider: 'openai',
+  },
+  {
+    title: 'Gemini-only host falls back from saved OpenAI',
+    requested: ['gemini'],
+    saved: 'openai',
+    expected: ['gemini'],
+    provider: 'gemini',
+  },
+  {
+    title: 'dual host restores Gemini',
+    requested: ['openai', 'gemini'],
+    saved: 'gemini',
+    expected: ['openai', 'gemini'],
+    provider: 'gemini',
+  },
+  {
+    title: 'unknown, duplicate and unavailable factories are excluded',
+    requested: ['unknown', 'gemini', 'openai', 'gemini'],
+    factories: ['gemini'],
+    saved: 'openai',
+    expected: ['gemini'],
+    provider: 'gemini',
+  },
+]) {
+  test(scenario.title, (t) => {
+    const f = compositionFixture(t, {
+      supportedProviders: scenario.requested,
+      factoryProviders: scenario.factories,
+      savedProvider: scenario.saved,
+    });
+    assert.deepEqual(f.facade.supportedProviders, scenario.expected);
+    assert.equal(Object.isFrozen(f.facade.supportedProviders), true);
+    assert.equal(f.facade.provider, scenario.provider);
+    assert.deepEqual(
+      f.views[0].providerSelect.options.map((option) => option.value),
+      scenario.expected,
+    );
+    assert.equal(
+      f.views[0].providerField.hidden,
+      scenario.expected.length === 1,
+    );
+    assert.equal(
+      f.views[0].root.dataset.providerChoice,
+      String(scenario.expected.length > 1),
+    );
+    assert.equal(f.instances.length, 1);
+    assert.equal(
+      f.instances[0].starts.length,
+      0,
+      'discovery must not start a provider',
+    );
+    assert.equal(f.facade.state, 'idle');
+  });
+}
+
+test('invalid or empty host support fails before mounting a control', () => {
+  let mounts = 0;
+  const dependencies = {
+    bind() {
+      mounts++;
+    },
+    factories: { openai() {} },
+  };
+  assert.throws(
+    () =>
+      createProviderCommands({ supportedProviders: 'gemini' }, dependencies),
+    /must be an array/,
+  );
+  assert.throws(
+    () =>
+      createProviderCommands(
+        { supportedProviders: ['gemini', 'unknown'] },
+        dependencies,
+      ),
+    /No supported voice provider/,
+  );
+  assert.equal(mounts, 0);
+});
+
+test('active switch keeps PTT mode, retires the held key, and disposes before mounting', async (t) => {
+  const f = compositionFixture(t);
+  const firstSession = f.facade.session;
+  const outerSignal = f.facade.signal;
+  const first = f.instances[0];
+  // PTT controls can activate the adapter directly; the facade must learn
+  // activity from its common events, not only from facade.start().
+  first.input.held = true;
+  await first.adapter.start({ pushToTalk: true });
+  assert.equal(first.microphoneEnabled, true);
+  assert.equal(f.facade.isActive(), true);
+  f.seedConversation();
+  const before = { ...f.counters };
+  f.select('gemini');
+  await settle();
+  const second = f.instances[1];
+  assert.equal(window.__gevVoiceCommands, f.facade);
+  assert.equal(f.facade.runner, f.runner);
+  assert.equal(f.facade.signal, outerSignal);
+  assert.equal(outerSignal.aborted, false);
+  assert.equal(firstSession.disposed, true);
+  assert.equal(first.hooks.signal.aborted, true);
+  assert.deepEqual(first.stops, [{ removeUi: true }]);
+  assert.equal(first.input.held, false);
+  assert.equal(first.microphoneEnabled, false);
+  assert.deepEqual(second.starts, [{ pushToTalk: true }]);
+  assert.equal(second.input.held, false);
+  assert.equal(
+    second.microphoneEnabled,
+    false,
+    'a held key must never migrate to the new adapter',
+  );
+  assert.equal(f.facade.state, 'listening');
+  assert.ok(f.order.indexOf('stop:0') < f.order.indexOf('control:1'));
+  assert.ok(f.order.indexOf('remove:0') < f.order.indexOf('control:1'));
+  assert.ok(f.order.indexOf('stop:0') < f.order.indexOf('factory:1'));
+  assert.equal(f.views[0].button.listenerCount('click'), 0);
+  assert.equal(f.views[0].providerSelect.listenerCount('change'), 0);
+  assert.equal(f.views[1].providerSelect.listenerCount('change'), 1);
+  assert.equal(f.views[1].providerSelect.focusCount, 1);
+  assert.equal(f.views[1].tierButton.hidden, true);
+  assert.equal(f.views[1].costValue.hidden, true);
+  assert.equal(f.facade.providerDiagnostic(), 'gemini:1');
+  assert.equal(f.pointer.activeSnapshot(), null);
+  assert.deepEqual(f.referents.list(), []);
+  for (const key of ['pointer', 'referents', 'conversation'])
+    assert.equal(
+      f.counters[key],
+      before[key] + 1,
+      `one explicit replacement reset: ${key}`,
+    );
+  assert.equal(
+    f.counters.dispose,
+    0,
+    'provider replacement keeps the page runner',
+  );
+  assert.deepEqual(f.storageWrites, [[PROVIDER_KEY, 'gemini']]);
+  assert.equal(f.facade.sendTextCommand('hello'), 'gemini:hello');
+  assert.deepEqual(first.texts, []);
+  assert.deepEqual(second.texts, ['hello']);
+  const result = await f.facade.runner('adjust_camera_zoom', {
+    direction: 'in',
+    amount: 'little',
+  });
+  assert.equal(
+    result.ok,
+    true,
+    'the actual shared action runner remains usable after switching',
+  );
+  assert.equal(f.state.zooms, 1);
+});
+
+for (const initialState of ['idle', 'error']) {
+  test(`${initialState} selection never autostarts; manual start still works`, async (t) => {
+    const f = compositionFixture(t, { storageDenied: true });
+    if (initialState === 'error') {
+      await f.facade.start({ pushToTalk: true });
+      f.instances[0].adapter.stop({ preserveStatus: true });
+      f.instances[0].hooks.emit({
+        type: 'state',
+        state: 'error',
+        detail: 'Fixture failure',
+      });
+    }
+    f.select('gemini');
+    await settle();
+    assert.equal(
+      f.facade.provider,
+      'gemini',
+      'denied storage cannot block a supported selection',
+    );
+    assert.equal(f.facade.state, 'idle');
+    assert.deepEqual(f.instances[1].starts, []);
+    f.select('gemini');
+    f.select('unknown');
+    assert.equal(
+      f.instances.length,
+      2,
+      'same and unsupported selections cannot remount',
+    );
+    assert.equal(f.facade.provider, 'gemini');
+    await f.facade.start({ pushToTalk: false });
+    assert.deepEqual(f.instances[1].starts, [{ pushToTalk: false }]);
+    assert.equal(f.instances[1].microphoneEnabled, true);
+  });
+}
+
+for (const outcome of ['resolve', 'reject']) {
+  test(`retired startup ${outcome} and stale events cannot affect the current mount`, async (t) => {
+    const f = compositionFixture(t, {
+      gateStarts: (instance) => instance.id === 0,
+    });
+    const oldStart = f.facade.start({ pushToTalk: false });
+    const old = f.instances[0];
+    assert.equal(f.facade.state, 'connecting');
+    f.select('gemini');
+    await settle();
+    assert.equal(f.facade.state, 'listening');
+    const current = f.instances[1];
+    const eventCount = f.events.length;
+    const currentStops = current.stops.length;
+    const currentCardCount = f.views[1].cardView.events.length;
+    old.gates[0][outcome](new Error('Late retired startup failure'));
+    await oldStart;
+    for (const state of ['idle', 'error', 'connecting']) {
+      old.hooks.emit({ type: 'state', state, detail: 'retired adapter' });
+      f.mounts[0].callback({
+        type: 'state',
+        state,
+        detail: 'retired forward callback',
+      });
+    }
+    assert.equal(f.events.length, eventCount);
+    assert.equal(f.views[1].cardView.events.length, currentCardCount);
+    assert.equal(f.facade.state, 'listening');
+    assert.equal(old.acquired, 0);
+    assert.equal(current.stops.length, currentStops);
+    assert.equal(current.starts.length, 1);
+    f.facade.stop();
+    f.mounts[0].callback({ type: 'state', state: 'connecting' });
+    f.select('openai');
+    assert.deepEqual(
+      f.instances[2].starts,
+      [],
+      'a retired connecting callback cannot revive voice intent',
+    );
+    assert.equal(f.facade.state, 'idle');
+  });
+}
+
+test('Stop during replacement startup defeats late settlement and further automatic resume', async (t) => {
+  const f = compositionFixture(t, {
+    gateStarts: (instance) => instance.id === 1,
+  });
+  await f.facade.start();
+  f.select('gemini');
+  const replacement = f.instances[1];
+  assert.equal(f.facade.state, 'connecting');
+  f.facade.stop();
+  replacement.gates[0].resolve();
+  await Promise.all(replacement.jobs);
+  assert.equal(replacement.acquired, 0);
+  assert.equal(f.facade.state, 'idle');
+  f.select('openai');
+  assert.deepEqual(f.instances[2].starts, []);
+  await f.facade.start();
+  assert.equal(
+    f.facade.state,
+    'listening',
+    'a later explicit start remains healthy',
+  );
+});
+
+for (const emitsIdle of [false, true]) {
+  test(`Stop and error clear pointer/referents/conversation once: adapter emitsIdle=${emitsIdle}`, async (t) => {
+    const f = compositionFixture(t);
+    if (emitsIdle) {
+      const instance = f.instances[0];
+      const originalStop = instance.adapter.stop;
+      instance.adapter.stop = function (settings = {}) {
+        originalStop.call(this, settings);
+        if (!settings.preserveStatus && !settings.removeUi)
+          instance.hooks.emit({ type: 'state', state: 'idle' });
+      };
+    }
+    for (const end of ['stop', 'error']) {
+      await f.facade.start();
+      f.seedConversation();
+      const before = { ...f.counters };
+      const generation = f.referents.generation();
+      if (end === 'stop') f.facade.stop();
+      else {
+        f.instances[0].adapter.stop({ preserveStatus: true });
+        f.instances[0].hooks.emit({
+          type: 'state',
+          state: 'error',
+          detail: 'Fixture failure',
+        });
+      }
+      assert.equal(f.pointer.activeSnapshot(), null);
+      assert.deepEqual(f.referents.list(), []);
+      assert.equal(f.referents.generation(), generation + 1);
+      for (const key of ['pointer', 'referents', 'conversation'])
+        assert.equal(f.counters[key], before[key] + 1, `${end}: ${key}`);
+    }
+  });
+}
+
+test('outer destruction disposes the runner once and removes each provider binding', async (t) => {
+  const priorUnsaved = describeUnsavedWork();
+  const f = compositionFixture(t);
+  await f.facade.start();
+  f.select('gemini');
+  await settle();
+  assert.equal(f.annotations.size, 1);
+  assert.ok(
+    describeUnsavedWork().includes(translate('the active voice session')),
+  );
+  const oldCardEvents = f.views[0].cardView.events.length;
+  for (const callback of f.annotations) callback({ id: 'fixture-outline' });
+  assert.equal(f.views[0].cardView.outlines.length, 0);
+  assert.equal(f.views[1].cardView.outlines.length, 1);
+  assert.equal(f.instances[1].mapEvents.length, 1);
+  f.facade.destroy();
+  f.facade.destroy();
+  f.facade.stop({ removeUi: true });
+  f.lifetime.abort();
+  assert.equal(f.counters.dispose, 1);
+  assert.equal(f.facade.signal.aborted, true);
+  assert.equal(f.facade.disposed, true);
+  assert.equal(f.annotations.size, 0);
+  assert.deepEqual(describeUnsavedWork(), priorUnsaved);
+  const finalEvents = f.events.length;
+  const starts = f.instances.map((instance) => instance.starts.length);
+  for (const [index, view] of f.views.entries()) {
+    assert.equal(view.root.removeCount, 1);
+    assert.equal(view.cardView.destroyed, 1);
+    assert.equal(view.reticle.destroyed, 1);
+    assert.equal(view.button.listenerCount('click'), 0);
+    assert.equal(view.providerSelect.listenerCount('change'), 0);
+    assert.equal(f.instances[index].hooks.signal.aborted, true);
+    view.button.dispatchEvent(new Event('click'));
+    view.providerSelect.value = 'openai';
+    view.providerSelect.dispatchEvent(new Event('change'));
+    f.instances[index].hooks.emit({ type: 'state', state: 'connecting' });
+    f.mounts[index].callback({ type: 'state', state: 'connecting' });
+  }
+  assert.equal(f.events.length, finalEvents);
+  assert.equal(f.views[0].cardView.events.length, oldCardEvents);
+  assert.deepEqual(
+    f.instances.map((instance) => instance.starts.length),
+    starts,
+  );
+  assert.equal(f.instances.length, 2);
+  assert.equal(f.facade.start(), false);
+  assert.equal(f.facade.sendText('after destroy'), false);
+  assert.equal(f.facade.notifyMapEvent({}), false);
+  const result = await f.facade.runner('adjust_camera_zoom', {
+    direction: 'in',
+    amount: 'little',
+  });
+  assert.equal(result.cancelled, true);
+  assert.equal(
+    f.state.zooms,
+    0,
+    'the actual runner cannot move the camera after outer disposal',
+  );
+});
+
+for (const action of ['stop', 'destroy']) {
+  for (const phase of ['common', 'adapter']) {
+    test(`${action} from replacement ${phase} connecting observer prevents resume`, async (t) => {
+      let intercepted = 0;
+      const f = compositionFixture(t, {
+        onSessionEvent(event, facade) {
+          if (
+            facade?.provider !== 'gemini' ||
+            event.type !== 'state' ||
+            event.state !== 'connecting'
+          )
+            return;
+          const matching =
+            phase === 'common'
+              ? event.detail === undefined
+              : event.detail === 'adapter:gemini';
+          if (matching && intercepted++ === 0) facade[action]();
+        },
+      });
+      await f.facade.start({ pushToTalk: true });
+      f.select('gemini');
+      await settle();
+      const replacement = f.instances[1];
+      assert.equal(intercepted, 1);
+      assert.equal(replacement.starts.length, phase === 'common' ? 0 : 1);
+      assert.equal(replacement.acquired, 0);
+      assert.equal(replacement.microphoneEnabled, false);
+      assert.equal(f.facade.isActive(), false);
+      assert.equal(f.facade.state, 'idle');
+      assert.equal(
+        f.events.filter(
+          (event) => event.state === 'listening' && event.detail === 'gemini',
+        ).length,
+        0,
+      );
+      assert.equal(f.facade.disposed, action === 'destroy');
+      assert.equal(f.counters.dispose, action === 'destroy' ? 1 : 0);
+      if (action === 'stop') {
+        f.select('openai');
+        assert.deepEqual(
+          f.instances[2].starts,
+          [],
+          'Stop cleared the intent to resume',
+        );
+        await f.facade.start({ pushToTalk: false });
+        assert.equal(f.facade.state, 'listening');
+      } else {
+        f.select('openai');
+        assert.equal(f.instances.length, 2);
+        assert.equal(f.facade.start(), false);
+      }
+    });
+  }
+}

src/voice/realtimeController.js

@@ -10,14 +10,13 @@ import { TurnMetrics } from './turnMetrics.js';
 import { createNarrationScheduler } from './narration.js';
 import { createEarcon } from './earcon.js';
 import {
+  POINTER_NONE_KEY,
   POINTER_OPEN_MIC_RECENT_MS,
-  pointerChip,
-  pointerContextItem,
+  pointerAnnouncement,
+  pointerTurnContext,
+  pointerTurnEvent,
 } from './pointerContext.js';
 
-/** Dedupe key of the clearing pointer_context item. */
-const POINTER_NONE_KEY = 'none';
-
 import { shouldPauseRadioForVoice } from './realtimeProtocol.js';
 import { postDebugLog } from './realtimeDiagnostics.js';
 
@@ -287,31 +286,18 @@ export class GevRealtimeController extends RealtimeFacade {
     } catch {
       snapshot = null;
     }
-    const chip = pointerChip(snapshot);
-    this.pointerAnnounced = gesture && chip ? snapshot : null;
-    this.emitSessionEvent({
-      type: 'pointer',
-      pointer:
-        gesture && chip ? { ...chip, screenPx: snapshot.screenPx } : null,
+    const event = pointerTurnEvent(snapshot, gesture);
+    this.pointerAnnounced = event.announced;
+    this.emitSessionEvent({ type: 'pointer', pointer: event.pointer });
+    const context = pointerTurnContext(snapshot, {
+      at,
+      gesture,
+      sentKey: this.pointerSentKey,
     });
-    const item = !chip
-      ? this.pointerSentKey && this.pointerSentKey !== POINTER_NONE_KEY
-        ? { type: 'pointer_context', at, target: 'none' }
-        : null
-      : gesture
-        ? pointerContextItem(snapshot)
-        : // What kind of thing, never which: no label or coordinates.
-          {
-            type: 'pointer_context',
-            at,
-            pointing: snapshot.entity?.kind || 'ground',
-          };
-    if (!item) return snapshot;
-    const { at: _at, ...content } = item;
-    const key = chip ? JSON.stringify(content) : POINTER_NONE_KEY;
-    if (key === this.pointerSentKey) return snapshot;
-    if (this._turns.notifyMapEvent(item)) {
-      this.pointerSentKey = key;
+    if (!context) return snapshot;
+    if (this._turns.notifyMapEvent(context.item)) {
+      this.pointerSentKey = context.key;
+      const chip = context.key !== POINTER_NONE_KEY;
       this.debugLog('pointer.context', {
         at,
         target: chip ? snapshot.target : 'none',
@@ -327,13 +313,10 @@ export class GevRealtimeController extends RealtimeFacade {
    */
   announcePointer() {
     const snapshot = this.pointer?.activeSnapshot?.() || null;
-    const chip = pointerChip(snapshot);
-    if (!chip || snapshot === this.pointerAnnounced) return false;
+    const pointer = pointerAnnouncement(snapshot, this.pointerAnnounced);
+    if (!pointer) return false;
     this.pointerAnnounced = snapshot;
-    this.emitSessionEvent({
-      type: 'pointer',
-      pointer: { ...chip, screenPx: snapshot.screenPx },
-    });
+    this.emitSessionEvent({ type: 'pointer', pointer });
     return true;
   }
 

src/voice/realtimeRadio.js

@@ -247,7 +247,9 @@ export class RealtimeRadio {
           handoffChannel?.readyState === 'open',
       },
     );
-    const stillCurrent = handoffEpoch === this.radioHandoffEpoch;
+    const stillCurrent =
+      handoffEpoch === this.radioHandoffEpoch &&
+      this.radioHandoffAttemptId === handoffAttemptId;
     if (this.radioHandoffAttemptId === handoffAttemptId) {
       this.radioHandoffInFlight = false;
       this.radioHandoffAttemptId = null;
@@ -266,6 +268,25 @@ export class RealtimeRadio {
     }
   }
 
+  /** Revoke one call's prepared/preflight result, preserving other owners. */
+  cancelPlaybackResult(result) {
+    if (!result) return;
+    if (this.pendingRadioPlaybackResult === result) {
+      this.pendingRadioPlaybackResult = null;
+      this.radioHandoffDeferredByReservation = false;
+    }
+    if (this.radioHandoffInFlightResult !== result) return;
+    const attemptId = this.radioHandoffAttemptId;
+    const shouldStopPlayback = this.radioHandoffInFlight;
+    this.radioHandoffInFlightResult = null;
+    this.radioHandoffInFlight = false;
+    this.radioHandoffAttemptId = null;
+    // Keep the group epoch and sibling reservations; release ownership before
+    // Stop can synchronously notify playback observers.
+    if (shouldStopPlayback)
+      this.radioLayer?.stopPlayback?.({ origin: 'voice-cleanup', attemptId });
+  }
+
   /** Invalidate delayed Radio work inside the requested authority scope. */
   abortRadioSiblingTools({ responseId = null, scope = 'all' } = {}) {
     for (const [controller, metadata] of this.activeRadioToolControllers) {

src/voice/realtimeRadio.test.mjs

@@ -0,0 +1,120 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { GevRealtimeController } from './realtimeController.js';
+
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+const playback = (id) => ({
+  ok: true,
+  action: 'control_radio',
+  radioAction: 'play',
+  radioPlaybackRequested: true,
+  id,
+});
+
+function fixture(t) {
+  const attempts = [],
+    stopped = [],
+    corrections = [],
+    states = [];
+  const controller = new GevRealtimeController({
+    ui: {
+      root: {
+        dataset: {},
+        classList: { remove() {} },
+        querySelectorAll: () => [],
+        remove() {},
+      },
+      status: {},
+      detail: {},
+      errorDetail: {},
+    },
+    runner: async () => ({ ok: false }),
+    debugSink: null,
+    onSessionEvent: (event) => states.push(event),
+    radioLayer: {
+      setVoiceDucked() {},
+      playForVoice: ({ attemptId }) =>
+        new Promise((resolve, reject) =>
+          attempts.push({ attemptId, resolve, reject }),
+        ),
+      stopPlayback: (options) => stopped.push(options),
+    },
+  });
+  controller.queueResponseCreate = (message) => corrections.push(message);
+  controller.dc = { readyState: 'open', send() {}, close() {} };
+  t.after(() => controller.stop({ removeUi: true }));
+  return { controller, attempts, stopped, corrections, states };
+}
+
+test('default OpenAI reservation silences rejected frozen preflight and resumes retained result after failure', async (t) => {
+  const h = fixture(t),
+    c = h.controller;
+  const a = playback('A');
+  c.pendingRadioPlaybackResult = a;
+  const pending = c.startPendingRadioHandoff();
+  const reservation = c.reserveRadioToolHandoff();
+  assert.equal(c.pendingRadioPlaybackResult, a);
+  assert.equal(c.radioHandoffInFlight, false);
+  h.attempts[0].reject(new Error('obsolete frozen preflight'));
+  await pending;
+  assert.deepEqual(h.corrections, []);
+  assert.equal(
+    h.states.some((event) => event.detail === 'Radio did not start'),
+    false,
+  );
+  c.settleRadioToolHandoffReservation(reservation, { commit: false });
+  await tick();
+  assert.equal(h.attempts.length, 2);
+  assert.equal(c.radioHandoffInFlightResult, a);
+  assert.notEqual(h.attempts[0].attemptId, h.attempts[1].attemptId);
+  h.attempts[1].reject(new Error('current preflight failed'));
+  await tick();
+  assert.equal(h.corrections.length, 1);
+  assert.equal(c.status, 'listening');
+});
+
+test('default OpenAI group cancellation silences rejected preflight without blocking the next failure correction', async (t) => {
+  const h = fixture(t),
+    c = h.controller;
+  c.pendingRadioPlaybackResult = playback('A');
+  const old = c.startPendingRadioHandoff();
+  c.cancelRadioHandoff();
+  h.attempts[0].reject(new Error('cancelled preflight'));
+  await old;
+  assert.deepEqual(h.corrections, []);
+  c.pendingRadioPlaybackResult = playback('B');
+  const current = c.startPendingRadioHandoff();
+  h.attempts[1].resolve(false);
+  await current;
+  assert.equal(h.corrections.length, 1);
+});
+
+test('per-result cancellation retains sibling result and epoch and ignores late failure or duplicate cancellation', async (t) => {
+  const h = fixture(t),
+    c = h.controller;
+  const a = playback('A'),
+    b = playback('B');
+  c.pendingRadioPlaybackResult = a;
+  const old = c.startPendingRadioHandoff();
+  const siblingEpoch = c.radioHandoffEpoch;
+  c.pendingRadioPlaybackResult = b;
+  c._radio.cancelPlaybackResult(a);
+  c._radio.cancelPlaybackResult(a);
+  c._radio.cancelPlaybackResult(playback('unknown'));
+  assert.equal(c.radioHandoffEpoch, siblingEpoch);
+  assert.equal(c.pendingRadioPlaybackResult, b);
+  assert.equal(h.stopped.length, 1);
+  h.attempts[0].reject(new Error('late cancelled preflight'));
+  await old;
+  assert.deepEqual(h.corrections, []);
+  const current = c.startPendingRadioHandoff();
+  const reservation = c.reserveRadioToolHandoff();
+  c._radio.cancelPlaybackResult(b);
+  assert.equal(c._radio.radioToolHandoffReservations.has(reservation), true);
+  h.attempts[1].resolve(false);
+  await current;
+  assert.deepEqual(h.corrections, []);
+  c.settleRadioToolHandoffReservation(reservation, { commit: false });
+  await tick();
+  assert.equal(h.attempts.length, 2, 'a cancelled result cannot be resumed');
+});

src/voice/realtimeSession.js

@@ -16,6 +16,7 @@ export function createRealtimeSession({
     controller,
     capabilities: { costControls: true, pushToTalk: true },
     start: (settings) => controller.start(settings),
+    getStartOptions: () => ({ pushToTalk: Boolean(controller.pushToTalkMode) }),
     stop: (settings) => controller.stop(settings),
     sendText: (text) => controller.sendTextCommand(text),
     sendMapEvent: (event) => controller.notifyMapEvent(event),

src/voice/realtimeTurns.js

@@ -137,7 +137,7 @@ export class RealtimeTurns {
         content: [{ type: 'input_text', text: cleanText }],
       },
     };
-    this.sendRealtimeEvent(itemEvent, 'client.user_text');
+    if (!this.sendRealtimeEvent(itemEvent, 'client.user_text')) return;
     this.requestUserTextResponse();
   }
 

src/voice/realtimeTypedSend.test.mjs

@@ -0,0 +1,268 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { GevRealtimeController } from './realtimeController.js';
+
+function fixture({ pointer = null, onUserSend = () => {} } = {}) {
+  const sent = [];
+  const executed = [];
+  const rejectedTexts = new Set();
+  let rejectResponse = false;
+  const controller = new GevRealtimeController({
+    runner: async (name) => {
+      executed.push(name);
+      return { ok: true };
+    },
+    backend: {},
+    debugSink: null,
+    pointer,
+    ui: {
+      root: {
+        dataset: {},
+        classList: { remove() {} },
+        querySelectorAll: () => [],
+      },
+      status: {},
+      detail: {},
+    },
+  });
+  controller.dc = {
+    readyState: 'open',
+    send(body) {
+      const value = JSON.parse(body);
+      const text = value.item?.role === 'user' && value.item.content?.[0]?.text;
+      if (value.item?.role === 'user') onUserSend();
+      if (
+        rejectedTexts.has(text) ||
+        (rejectResponse && value.type === 'response.create')
+      )
+        throw new Error('Synthetic channel rejection');
+      sent.push(value);
+    },
+    close() {
+      this.readyState = 'closed';
+    },
+  };
+  controller.status = 'listening';
+  controller._turns.narration = null;
+  const event = (payload) =>
+    controller.handleRealtimeEvent({ data: JSON.stringify(payload) });
+  const created = (id) => event({ type: 'response.created', response: { id } });
+  const done = (id) =>
+    event({
+      type: 'response.done',
+      response: { id, status: 'completed', output: [] },
+    });
+  const creates = () =>
+    sent.filter(
+      (x) =>
+        x.type === 'response.create' &&
+        x.response?.metadata?.gev !== 'progress',
+    );
+  const texts = () =>
+    sent
+      .filter((x) => x.item?.role === 'user')
+      .map((x) => x.item.content[0].text);
+  return {
+    controller,
+    sent,
+    executed,
+    rejectedTexts,
+    event,
+    created,
+    done,
+    creates,
+    texts,
+    rejectResponses(value) {
+      rejectResponse = value;
+    },
+  };
+}
+
+test('rejected idle text schedules no answer, and a successful successor answers once', async () => {
+  const f = fixture();
+  try {
+    f.rejectedTexts.add('rejected');
+    assert.equal(f.controller.sendTextCommand('rejected'), undefined);
+    assert.equal(f.creates().length, 0);
+    assert.equal(f.controller.pendingUserTextResponse, false);
+    assert.equal(f.controller.responseCreatePending, false);
+    assert.equal(f.controller.sendTextCommand('successor'), undefined);
+    assert.deepEqual(f.texts(), ['successor']);
+    assert.equal(f.creates().length, 1);
+    await f.created('successor');
+    await f.done('successor');
+    assert.equal(f.creates().length, 1);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+test('rejected text behind an active response cannot queue an answer', async () => {
+  const f = fixture();
+  try {
+    await f.created('active');
+    f.controller.queueResponseCreate('Old tool follow-up');
+    assert.equal(
+      f.controller.pendingResponseInstructions,
+      'Old tool follow-up',
+    );
+    const runningTool = new AbortController();
+    f.controller._turns.activeToolAbortControllers.add(runningTool);
+    f.rejectedTexts.add('rejected');
+    f.controller.sendTextCommand('rejected');
+    assert.equal(f.controller.pendingUserTextResponse, false);
+    assert.equal(f.controller.pendingResponseInstructions, null);
+    assert.equal(f.controller._turns.isSupersededResponse('active'), true);
+    assert.equal(runningTool.signal.aborted, true);
+    const staleCall = {
+      type: 'response.function_call_arguments.done',
+      response_id: 'active',
+      call_id: 'stale-call',
+      name: 'fly_to_location',
+      arguments: '{"query":"Paris"}',
+    };
+    await f.event(staleCall);
+    await f.event(staleCall);
+    assert.deepEqual(f.executed, []);
+    const outputs = f.sent.filter(
+      (x) => x.item?.type === 'function_call_output',
+    );
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0].item.call_id, 'stale-call');
+    assert.equal(JSON.parse(outputs[0].item.output).superseded, true);
+    await f.done('active');
+    assert.equal(f.creates().length, 0);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+test('rejected text still prepares narration and pointer context before sending', () => {
+  const steps = [];
+  const f = fixture({
+    pointer: {
+      beginTurn() {
+        steps.push('pointer');
+        return null;
+      },
+      clear() {},
+    },
+    onUserSend() {
+      steps.push('send');
+    },
+  });
+  f.controller._turns.narration = {
+    cancel() {
+      steps.push('cancel');
+    },
+    userTurnEnded() {
+      steps.push('user-turn-ended');
+    },
+  };
+  try {
+    f.rejectedTexts.add('rejected');
+    f.controller.sendTextCommand('rejected');
+    assert.deepEqual(steps, ['cancel', 'user-turn-ended', 'pointer', 'send']);
+    assert.equal(f.creates().length, 0);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+test('earlier accepted deferred input survives a newer failed send and answers once', async () => {
+  const f = fixture();
+  try {
+    await f.created('active');
+    f.controller.sendTextCommand('accepted');
+    f.rejectedTexts.add('rejected');
+    f.controller.sendTextCommand('rejected');
+    assert.deepEqual(f.texts(), ['accepted']);
+    assert.equal(f.controller.pendingUserTextResponse, true);
+    assert.equal(f.creates().length, 0);
+    await f.done('active');
+    assert.equal(f.creates().length, 1);
+    await f.done('active');
+    assert.equal(f.creates().length, 1);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+test('rejected text preserves an outstanding create without adding deferred input', async () => {
+  const f = fixture();
+  try {
+    f.controller.sendTextCommand('accepted');
+    f.rejectedTexts.add('rejected');
+    f.controller.sendTextCommand('rejected');
+    assert.equal(f.controller.responseCreatePending, true);
+    assert.equal(f.controller.pendingUserTextResponse, false);
+    await f.created('accepted');
+    await f.done('accepted');
+    assert.equal(f.creates().length, 1);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+for (const acceptedFirst of [false, true]) {
+  test(`progress completion answers only accepted deferred input (accepted first=${acceptedFirst})`, async () => {
+    const f = fixture();
+    try {
+      assert.equal(
+        f.controller._turns.speakProgressLine('Checking the map.'),
+        true,
+      );
+      await f.event({
+        type: 'response.created',
+        response: { id: 'progress', metadata: { gev: 'progress' } },
+      });
+      if (acceptedFirst) f.controller.sendTextCommand('accepted');
+      f.rejectedTexts.add('rejected');
+      f.controller.sendTextCommand('rejected');
+      assert.equal(f.controller.pendingUserTextResponse, acceptedFirst);
+      await f.event({
+        type: 'response.done',
+        response: {
+          id: 'progress',
+          status: 'cancelled',
+          metadata: { gev: 'progress' },
+        },
+      });
+      assert.equal(f.creates().length, acceptedFirst ? 1 : 0);
+    } finally {
+      f.controller.stop();
+    }
+  });
+}
+
+test('accepted text with a rejected response.create releases the pending latch for a successor', async () => {
+  const f = fixture();
+  try {
+    f.rejectResponses(true);
+    f.controller.sendTextCommand('accepted without response');
+    assert.equal(f.controller.responseCreatePending, false);
+    assert.equal(f.creates().length, 0);
+    f.rejectResponses(false);
+    f.controller.sendTextCommand('successor');
+    assert.deepEqual(f.texts(), ['accepted without response', 'successor']);
+    assert.equal(f.creates().length, 1);
+  } finally {
+    f.controller.stop();
+  }
+});
+
+test('successful deferred typed burst still retains both items and coalesces one answer', async () => {
+  const f = fixture();
+  try {
+    await f.created('active');
+    f.controller.sendTextCommand('first');
+    f.controller.sendTextCommand('second');
+    assert.deepEqual(f.texts(), ['first', 'second']);
+    assert.equal(f.creates().length, 0);
+    await f.done('active');
+    await f.done('active');
+    assert.equal(f.creates().length, 1);
+  } finally {
+    f.controller.stop();
+  }
+});

src/voice/session.js

@@ -147,8 +147,9 @@ export function createVoiceSession({ createAdapter, runner, signal }) {
     },
     async start(options) {
       if (disposed || !['idle', 'error'].includes(state)) return;
-      emit({ type: 'state', state: 'connecting' });
       const attempt = ++startAttempt;
+      emit({ type: 'state', state: 'connecting' });
+      if (disposed || attempt !== startAttempt) return;
       try {
         await adapter.start(options);
       } catch (error) {
@@ -164,12 +165,17 @@ export function createVoiceSession({ createAdapter, runner, signal }) {
     stop(options = {}) {
       if (options.removeUi) return dispose();
       if (disposed) return;
-      startAttempt++;
+      const attempt = ++startAttempt;
       cancelActions();
       try {
         adapter.stop(options);
       } finally {
-        if (!options.preserveStatus)
+        if (
+          !options.preserveStatus &&
+          !disposed &&
+          attempt === startAttempt &&
+          state !== 'idle'
+        )
           emit({ type: 'state', state: 'idle', detail: 'Voice off' });
       }
     },

src/voice/session.test.mjs

@@ -6,6 +6,7 @@ import {
   voiceCardView,
 } from './voiceCardPresentation.js';
 import { createVoiceSession } from './session.js';
+import { createRealtimeSession } from './realtimeSession.js';
 import { realtimeSessionEvent } from './realtimeEvents.js';
 import { createVoiceCommands } from './sessionCommands.js';
 import { describeUnsavedWork } from '../i18n/index.js';
@@ -441,3 +442,189 @@ test('a late rejection cannot settle a newer turn card', async () => {
   );
   f.session.destroy();
 });
+
+function startReentrancyFixture() {
+  let starts = 0;
+  let stops = 0;
+  const settings = [];
+  const session = createVoiceSession({
+    runner: async () => ({ ok: true }),
+    createAdapter: ({ emit }) => ({
+      async start(options) {
+        starts++;
+        settings.push(options);
+        emit({ type: 'state', state: 'listening' });
+      },
+      stop() {
+        stops++;
+      },
+      sendText() {},
+      sendMapEvent() {},
+    }),
+  });
+  return { session, settings, starts: () => starts, stops: () => stops };
+}
+
+for (const action of ['stop', 'destroy']) {
+  test(`initial connecting observer ${action} prevents adapter acquisition`, async () => {
+    const f = startReentrancyFixture();
+    const unsubscribe = f.session.subscribe((event) => {
+      if (event.type === 'state' && event.state === 'connecting') {
+        unsubscribe();
+        f.session[action]();
+      }
+    });
+    await f.session.start();
+    assert.equal(
+      f.starts(),
+      0,
+      'cancelled attempt must not call adapter.start',
+    );
+    assert.equal(f.stops(), 1);
+    assert.equal(f.session.state, 'idle');
+    if (action === 'stop') {
+      await f.session.start();
+      assert.equal(f.starts(), 1, 'later explicit Start remains usable');
+      assert.equal(f.session.state, 'listening');
+    }
+    f.session.destroy();
+  });
+}
+
+test('preserveStatus Stop still prevents adapter acquisition', async () => {
+  const f = startReentrancyFixture();
+  const unsubscribe = f.session.subscribe((event) => {
+    if (event.type === 'state' && event.state === 'connecting') {
+      unsubscribe();
+      f.session.stop({ preserveStatus: true });
+    }
+  });
+  await f.session.start();
+  assert.equal(f.starts(), 0);
+  assert.equal(
+    f.session.state,
+    'connecting',
+    'preserved state is not ownership',
+  );
+  f.session.stop();
+  await f.session.start();
+  assert.equal(f.starts(), 1);
+  f.session.destroy();
+});
+
+test('Stop and explicit reentrant successor start acquire only for the successor', async () => {
+  const f = startReentrancyFixture();
+  let successor;
+  const unsubscribe = f.session.subscribe((event) => {
+    if (event.type === 'state' && event.state === 'connecting') {
+      unsubscribe();
+      f.session.stop();
+      successor = f.session.start();
+    }
+  });
+  await f.session.start();
+  await successor;
+  assert.equal(f.starts(), 1);
+  assert.equal(f.session.state, 'listening');
+  f.session.destroy();
+});
+
+test('ordinary start forwards caller settings once and remains stoppable', async () => {
+  const f = startReentrancyFixture();
+  const settings = { pushToTalk: true };
+  await f.session.start(settings);
+  assert.equal(f.settings.length, 1);
+  assert.equal(f.settings[0], settings);
+  assert.equal(f.starts(), 1);
+  assert.equal(f.session.state, 'listening');
+  f.session.stop();
+  assert.equal(f.session.state, 'idle');
+  f.session.destroy();
+});
+
+for (const emitsIdle of [false, true]) {
+  for (const outcome of ['normal', 'preserveStatus', 'throw']) {
+    test(`stop preserves custom adapter contract: emitsIdle=${emitsIdle}, ${outcome}`, async (t) => {
+      let adapter;
+      const calls = [];
+      const events = [];
+      const failure = new Error('Controlled stop failure');
+      const session = createVoiceSession({
+        runner: async () => ({}),
+        createAdapter: ({ emit }) =>
+          (adapter = {
+            async start() {
+              emit({ type: 'state', state: 'listening' });
+            },
+            stop(settings = {}) {
+              calls.push({ receiver: this, settings });
+              if (settings.removeUi) return;
+              if (emitsIdle && !settings.preserveStatus)
+                emit({ type: 'state', state: 'idle' });
+              if (outcome === 'throw') throw failure;
+              return 'adapter-only return';
+            },
+            sendText() {},
+            sendMapEvent() {},
+          }),
+      });
+      t.after(() => session.destroy());
+      session.subscribe((event) => events.push(event));
+      await session.start();
+      events.length = 0;
+      const settings =
+        outcome === 'preserveStatus' ? { preserveStatus: true } : {};
+      if (outcome === 'throw')
+        assert.throws(
+          () => session.stop(settings),
+          (error) => error === failure,
+        );
+      else assert.equal(session.stop(settings), undefined);
+      assert.equal(calls[0].receiver, adapter);
+      assert.equal(calls[0].settings, settings);
+      assert.equal(
+        session.state,
+        outcome === 'preserveStatus' ? 'listening' : 'idle',
+      );
+      assert.equal(
+        events.filter(
+          (event) => event.type === 'state' && event.state === 'idle',
+        ).length,
+        outcome === 'preserveStatus' ? 0 : 1,
+      );
+    });
+  }
+}
+
+test('actual default OpenAI adapter stop publishes one common idle', (t) => {
+  const events = [];
+  const ui = {
+    root: {
+      dataset: {},
+      querySelectorAll: () => [],
+      classList: { remove() {} },
+      remove() {},
+    },
+    status: {},
+    detail: {},
+  };
+  const runner = async () => ({});
+  const session = createVoiceSession({
+    runner,
+    createAdapter: (hooks) =>
+      createRealtimeSession({ ...hooks, runner, ui, debugSink() {} }),
+  });
+  t.after(() => session.destroy());
+  session.subscribe((event) => events.push(event));
+  // Exercise the real stop path without acquiring microphone/WebRTC resources.
+  session.adapter.controller.setStatus('listening', 'Controlled active state');
+  events.length = 0;
+  session.stop();
+  assert.equal(
+    events.filter((event) => event.type === 'state' && event.state === 'idle')
+      .length,
+    1,
+  );
+  assert.equal(session.state, 'idle');
+  assert.equal(session.adapter.controller.status, 'idle');
+});

src/voice/sessionCommands.js

@@ -2,6 +2,7 @@ import { createVoiceControl, voiceStatusLabel } from './control.js';
 import { createVoiceSession } from './session.js';
 import { VoiceCardControls } from './voiceCard.js';
 import { PointerReticle } from './pointerReticle.js';
+import { VOICE_PROVIDERS } from './providerCapabilities.js';
 import { msg, registerUnsavedWork, t } from '../i18n/index.js';
 
 function createDefaultReticle(pointer) {
@@ -25,12 +26,18 @@ export function createVoiceCommands({
   signal,
   debugSink,
   createControl = createVoiceControl,
+  resetExisting = true,
+  disposeRunner = true,
+  provider,
+  supportedProviders,
+  onProviderChange,
+  onSessionEvent,
   createCard = (options) => new VoiceCardControls(options),
   pointer = null,
   referents = null,
   createReticle = createDefaultReticle,
 }) {
-  window.__gevVoiceCommands?.stop?.({ removeUi: true });
+  if (resetExisting) window.__gevVoiceCommands?.stop?.({ removeUi: true });
   const ui = createControl({ reset: true });
   const session = createVoiceSession({
     runner,
@@ -50,6 +57,34 @@ export function createVoiceCommands({
   });
   const adapter = session.adapter;
   const capabilities = adapter.capabilities || {};
+  const providerHandler = () => onProviderChange?.(ui.providerSelect.value);
+  if (ui.providerSelect && onProviderChange) {
+    if (supportedProviders && ui.providerSelect.replaceChildren) {
+      const doc = ui.providerSelect.ownerDocument;
+      ui.providerSelect.replaceChildren(
+        ...supportedProviders.map((name) => {
+          const option = doc.createElement('option');
+          option.value = name;
+          option.textContent = VOICE_PROVIDERS[name].label;
+          return option;
+        }),
+      );
+    }
+    ui.providerSelect.value = provider;
+    ui.providerSelect.title = [
+      t('Changing provider reconnects voice if it is on.'),
+      capabilities.advisoryLimit,
+    ]
+      .filter(Boolean)
+      .join(' ');
+    ui.providerSelect.addEventListener('change', providerHandler);
+    ui.root.dataset.provider = provider;
+  }
+  const hasProviderChoice = Boolean(
+    onProviderChange && supportedProviders?.length > 1,
+  );
+  if (ui.providerField) ui.providerField.hidden = !hasProviderChoice;
+  ui.root.dataset.providerChoice = String(hasProviderChoice);
   if (ui.tierButton) ui.tierButton.hidden = !capabilities.costControls;
   if (ui.costValue) ui.costValue.hidden = !capabilities.costControls;
   if (!capabilities.pushToTalk) {
@@ -60,6 +95,7 @@ export function createVoiceCommands({
   // Retain the existing controller's inspection surface for browser tools.
   const controls = adapter.controller || session;
   controls.session = session;
+  controls.ui = ui;
   const updateStatus = session.subscribe((event) => {
     if (event.type !== 'state') return;
     ui.root.dataset.status = event.state;
@@ -101,6 +137,10 @@ export function createVoiceCommands({
   });
   controls.pointer = pointer;
   controls.referents = referents;
+  // Forward last: a host observer may synchronously replace or stop this mount.
+  const forwardEvents = onSessionEvent
+    ? session.subscribe(onSessionEvent)
+    : null;
   const annotationUnsubscribe = annotations?.onOutlineEvent?.((event) => {
     card?.outline(event);
     session.sendMapEvent({ type: 'map_annotation_outline', ...event });
@@ -115,34 +155,26 @@ export function createVoiceCommands({
     else void session.start({ pushToTalk: false });
   };
   ui.button.addEventListener('click', buttonHandler);
-  session.signal.addEventListener(
-    'abort',
-    () => {
-      ui.button.removeEventListener('click', buttonHandler);
-      unregisterUnsavedWork();
-      annotationUnsubscribe?.();
-      updateStatus();
-      updateCard?.();
-      updatePointer();
-      reticle?.destroy();
-      card?.destroy();
-      runner.dispose?.();
-      ui.root.remove();
-    },
-    { once: true },
-  );
-  if (session.disposed) {
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
     ui.button.removeEventListener('click', buttonHandler);
+    ui.providerSelect?.removeEventListener('change', providerHandler);
     unregisterUnsavedWork();
     annotationUnsubscribe?.();
     updateStatus();
     updateCard?.();
     updatePointer();
+    forwardEvents?.();
     reticle?.destroy();
     card?.destroy();
-    runner.dispose?.();
+    if (disposeRunner) runner.dispose?.();
     ui.root.remove();
-  } else adapter.bindControls?.();
+  };
+  session.signal.addEventListener('abort', cleanup, { once: true });
+  if (session.disposed) cleanup();
+  else adapter.bindControls?.();
   window.__gevVoiceCommands = controls;
   return controls;
 }