feat(01-08): wire the turn loop - text and voice turns, thinking, replay, slower, latency

- avatar/turn-loop.js: dispatchTurn engages the thinking pose before the first await,
calls the host bridge with one JSON argument, speaks the directive, stamps
lastTurnMs at speech-start (where thinking clears) and publishes lastStageTimings,
lastSubtitle, turnCount, replayCount and lastReplayMs; replay stays networkless;
requestSlower re-dispatches the last subtitle at speedScale 0.75; the deferred stubs
are gone. Implemented once - avatar.js and avatar-iframe.js changed by zero lines.
- avatar/host.js (new): the host glue, loaded by the shared boot template for both
transports. Binds Enter/Send/Say hello/Replay/Slower/push-to-talk to the facade,
echoes typed text before the round trip, renders status, transcript, the latency
breakdown and the ASR tier badge, disables the controls while thinking or speaking
and re-arms them 200 ms after speech-end. Skips the Enter that ends an IME composition.
- avatar/vrm-stage.js publishes headPitch and relaxedValue so the thinking pose is a
rendered number, not a flag.
- tests: standalone thinking-pose test; parity suite now drives a real turn, the
thinking transition, a request-counted replay and a slower re-read under BOTH
transports and retires the deferred-stub guard; seam guards for the ordering, the
networkless replay, the published numbers and the host glue; the remount test drives
the wave-5 controls.

The turn loop's getDebug() returns the facade's live merged object, so probes read
scalars out the moment they sample.

avatar/host.js

@@ -0,0 +1,235 @@
+// avatar/host.js
+//
+// THE HOST GLUE: binds the page's controls to window.Avatar and renders what the avatar
+// reports. It is the only module in avatar/ that knows the controls' element ids, and it
+// knows NOTHING about which transport booted - it is handed the facade object and talks
+// to nothing else. Both transports load it from the same boot template, so the controls
+// behave identically under either by construction.
+//
+// It implements no turn behaviour. Every control below is one call into the facade;
+// the behaviour lives in avatar/turn-loop.js. tests/test_transport_seam.py enforces
+// both halves of that: this file is imported by no transport and defines no turn method.
+//
+// DOM writes go to inner elements this project owns (#status-text, #transcript-text,
+// #latency-text, #asr-tier-text) rather than to the host's wrapper elements, so a
+// re-render of a wrapper cannot delete a line, and user-supplied text is always written
+// through textContent, never innerHTML.
+
+/** Matches REARM_TAIL_MS in mic.js: the controls re-enable when the mic may re-arm. */
+const REENABLE_AFTER_SPEECH_MS = 200;
+
+/** Enter finishes a Japanese IME composition before it submits; this skips that Enter. */
+function isComposing(event) {
+  return event.isComposing || event.keyCode === 229;
+}
+
+/**
+ * @param {object}   avatar the facade window.Avatar
+ * @param {Document} [doc]
+ * @returns {boolean} whether the bindings were installed by this call
+ */
+export function bindHost(avatar, doc = document) {
+  if (!avatar || typeof avatar.on !== 'function') return false;
+  // boot() is re-entrant and returns the live object; the bindings must not double up.
+  if (doc.__avatarHostBound) return false;
+  doc.__avatarHostBound = true;
+
+  const byId = (id) => doc.getElementById(id);
+  const text = (id, value) => {
+    const el = byId(id);
+    if (el) el.textContent = value;
+  };
+  const status = (value) => text('status-text', value);
+
+  const textarea = () => doc.querySelector('#text-input textarea, #text-input input');
+  const controls = {
+    ptt: byId('ptt-button'),
+    hello: byId('hello-button'),
+    send: byId('send-button'),
+    replay: byId('replay-button'),
+    slower: byId('slower-button'),
+  };
+
+  let spoken = false; // whether anything has been said yet, for replay/slower
+  let busy = false;
+  let reenableTimer = null;
+
+  function applyEnabled() {
+    for (const [name, el] of Object.entries(controls)) {
+      if (!el) continue;
+      const needsSpeech = name === 'replay' || name === 'slower';
+      el.disabled = busy || (needsSpeech && !spoken);
+    }
+  }
+
+  function setBusy(value) {
+    busy = !!value;
+    if (reenableTimer) {
+      clearTimeout(reenableTimer);
+      reenableTimer = null;
+    }
+    applyEnabled();
+  }
+
+  function transcriptLine(who, value) {
+    const el = byId('transcript-text');
+    if (!el) return;
+    const line = doc.createElement('div');
+    line.className = `turn turn-${who}`;
+    const label = doc.createElement('span');
+    label.className = 'who';
+    label.textContent = who === 'you' ? 'You: ' : who === 'slower' ? 'Avatar (slower): ' : 'Avatar: ';
+    const body = doc.createElement('span');
+    body.className = 'said';
+    body.textContent = value;
+    line.append(label, body);
+    el.append(line);
+    el.scrollTop = el.scrollHeight;
+  }
+
+  function renderLatency({ lastTurnMs, timings }) {
+    const t = timings || {};
+    const ms = (key) => (typeof t[key] === 'number' ? Math.round(t[key]) : '—');
+    text(
+      'latency-text',
+      `dispatch→speech: ${lastTurnMs} ms  (server: query ${ms('audio_query_ms')} / ` +
+        `synth ${ms('synthesis_ms')} / timeline ${ms('timeline_ms')} / encode ${ms('encode_ms')})`
+    );
+  }
+
+  function renderTier({ tier, model, dtype }) {
+    const shortModel = String(model || '').split('/').pop();
+    const label = tier === 'webgpu' ? 'WebGPU' : tier === 'wasm' ? 'WASM' : String(tier);
+    text('asr-tier-text', `ASR: ${label} · ${shortModel} ${dtype || ''}`.trim());
+  }
+
+  function report(err) {
+    status(`error: ${String(err?.message ?? err)}`);
+  }
+
+  function dispatch(value, opts) {
+    setBusy(true);
+    status('thinking…');
+    avatar.dispatchTurn(value, opts).catch(report);
+  }
+
+  function submitText() {
+    const el = textarea();
+    const value = el ? el.value.trim() : '';
+    if (!value) {
+      status('type something in Japanese first');
+      return;
+    }
+    // Echo before the round trip, so the visitor sees their words the instant they send.
+    transcriptLine('you', value);
+    if (el) {
+      el.value = '';
+      // The host's textbox mirrors its value from input events; a bare .value write
+      // would leave the host believing the old text is still there.
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+    dispatch(value);
+  }
+
+  // ------------------------------------------------------------------- avatar -> page
+  avatar.on('listening', ({ active } = {}) => status(active ? 'listening…' : 'transcribing…'));
+  avatar.on('transcript', ({ text: heard } = {}) => {
+    if (!heard) return;
+    transcriptLine('you', heard);
+    dispatch(heard);
+  });
+  avatar.on('turn-start', () => {
+    setBusy(true);
+    status('thinking…');
+  });
+  avatar.on('turn', ({ subtitle, speed, greeting } = {}) => {
+    if (subtitle && (greeting || speed < 1)) transcriptLine(speed < 1 ? 'slower' : 'avatar', subtitle);
+    spoken = true;
+  });
+  avatar.on('speech-start', () => {
+    setBusy(true);
+    status('speaking…');
+  });
+  avatar.on('speech-end', () => {
+    status('ready');
+    reenableTimer = setTimeout(() => setBusy(false), REENABLE_AFTER_SPEECH_MS);
+  });
+  avatar.on('latency', renderLatency);
+  avatar.on('asr-tier', renderTier);
+  avatar.on('error', ({ message, where } = {}) => {
+    setBusy(false);
+    status(`error (${where || 'avatar'}): ${message}`);
+  });
+
+  // ------------------------------------------------------------------- page -> avatar
+  if (controls.send) controls.send.addEventListener('click', submitText);
+
+  const input = textarea();
+  if (input) {
+    input.addEventListener('keydown', (event) => {
+      if (event.key !== 'Enter' || event.shiftKey || isComposing(event)) return;
+      event.preventDefault();
+      submitText();
+    });
+  }
+
+  if (controls.hello) {
+    controls.hello.addEventListener('click', () => dispatch('', { greeting: true }));
+  }
+
+  if (controls.replay) {
+    controls.replay.addEventListener('click', () => {
+      setBusy(true);
+      avatar.replay().catch(report);
+    });
+  }
+
+  if (controls.slower) {
+    controls.slower.addEventListener('click', () => {
+      setBusy(true);
+      status('thinking…');
+      avatar.requestSlower().catch(report);
+    });
+  }
+
+  if (controls.ptt) {
+    const ptt = controls.ptt;
+    ptt.style.touchAction = 'none';
+    ptt.addEventListener('contextmenu', (event) => event.preventDefault());
+    ptt.addEventListener('pointerdown', (event) => {
+      event.preventDefault();
+      if (ptt.setPointerCapture) {
+        try {
+          ptt.setPointerCapture(event.pointerId);
+        } catch {
+          /* capture is a nicety; release still arrives on the button */
+        }
+      }
+      avatar
+        .startListening()
+        .then(async (started) => {
+          if (started) return;
+          const d = await avatar.getDebug();
+          status(`microphone did not open (${d.micLastRejectReason || 'refused'})`);
+        })
+        .catch(report);
+    });
+    const release = () => {
+      avatar
+        .stopListening()
+        .then(async (heard) => {
+          if (heard) return; // the 'transcript' event has already dispatched the turn
+          const d = await avatar.getDebug();
+          const reason = d.micLastRejectReason ? ` (${d.micLastRejectReason})` : '';
+          status(`didn't catch that${reason} - hold the button and speak`);
+        })
+        .catch(report);
+    };
+    ptt.addEventListener('pointerup', release);
+    ptt.addEventListener('pointercancel', release);
+  }
+
+  applyEnabled();
+  status('ready - hold the button and speak, or type Japanese below');
+  return true;
+}

avatar/turn-loop.js

@@ -14,20 +14,19 @@
 // two transport files needed zero lines of change to gain push-to-talk, which is the
 // strongest possible form of the guarantee the seam exists to give. Both are still
 // injectable through the factory so a harness can substitute a different model.
+//
+// The turn itself landed in wave 5, in this file and nowhere else, so the same holds:
+// dispatchTurn, replay and requestSlower work under both transports because there is
+// exactly one implementation of each. The bridge object getServer() returns exposes
+// the host-registered functions (turn, greeting) as async methods; this module calls
+// them with ONE argument each, because the host's bridge packs multiple arguments into
+// a list and the far side would receive that list as a single positional.
 
 import { createAsr } from './asr.js';
 import { createMic, isHallucination, REJECT } from './mic.js';
 
-/**
- * A deferred method. Calling one now fails loudly and names the plan that fills it in,
- * which is the difference between a placeholder and an accidental no-op. The parity
- * guard is therefore meaningful from this wave rather than only after the last one.
- */
-function notWiredYet(name, plan) {
-  return () => {
-    throw new Error(`Avatar.${name}() is not wired yet - plan ${plan} implements it`);
-  };
-}
+/** VOICEVOX speedScale for the "Slower" re-read. Divides every phoneme length. */
+export const SLOWER_SPEED = 0.75;
 
 /**
  * @param {object}   opts
@@ -57,30 +56,57 @@ export function createTurnLoop({
   const state = {
     thinking: false,
     listening: false,
+    speaking: false,
     lastTurnId: null,
     replayCount: 0,
+    turnCount: 0,
+    // The number that matters: dispatch (Enter, click or mic release) to the first
+    // scheduled audio sample, in milliseconds, for the most recent turn.
+    lastTurnMs: null,
+    lastReplayMs: null,
+    lastStageTimings: null,
+    lastSubtitle: null,
+    lastSpeed: null,
+    lastError: null,
     asrTier: null,
     asrModel: null,
     lastTranscript: null,
     micRejectedCount: 0,
+    micLastRejectReason: null,
   };
 
-  let speaking = false;
+  // Set when a turn or a replay has been dispatched and its speech-start has not yet
+  // been observed. speech-start is the event that closes the "thinking" window and
+  // stamps lastTurnMs, so it is measured where the event arrives - the same place under
+  // both transports - rather than guessed at from the speak() promise.
+  let pendingDispatchAt = null;
+  let pendingReplayAt = null;
+
+  const now = () => performance.now();
 
-  function setListeningState(on) {
+  function setThinking(value) {
+    const on = !!value;
+    state.thinking = on;
+    stagePort.setThinking(on);
+    return on;
+  }
+
+  function setListening(value) {
+    const on = !!value;
     state.listening = on;
     stagePort.setListening(on);
+    return on;
   }
 
   const micInstance =
     mic ||
     createMic({
       emit,
-      onListening: setListeningState,
+      onListening: setListening,
       // Push-to-talk exists to make acoustic feedback impossible, so the mic refuses to
       // open while the avatar is thinking or speaking. mic.js adds the 200 ms tail after
       // speech-end on top of this.
-      isBusy: () => state.thinking || speaking,
+      isBusy: () => state.thinking || state.speaking,
       ...micOptions,
     });
 
@@ -94,9 +120,34 @@ export function createTurnLoop({
    */
   function observe(name, data) {
     if (name === 'speech-start') {
-      speaking = true;
+      state.speaking = true;
+      if (pendingDispatchAt !== null) {
+        state.lastTurnMs = Math.round(now() - pendingDispatchAt);
+        pendingDispatchAt = null;
+        performance.mark('turn:speech-start');
+        try {
+          performance.measure('turn:dispatch-to-speech', 'turn:dispatch', 'turn:speech-start');
+        } catch {
+          /* a mark was cleared; the number is already in lastTurnMs */
+        }
+        // The thinking pose clears HERE, at speech-start, not when the response arrives:
+        // decode and scheduling still sit between the two, and the face must not go idle
+        // while the visitor is still waiting to hear something.
+        setThinking(false);
+        emit('latency', {
+          turnId: state.lastTurnId,
+          lastTurnMs: state.lastTurnMs,
+          timings: state.lastStageTimings,
+          speed: state.lastSpeed,
+        });
+      }
+      if (pendingReplayAt !== null) {
+        state.lastReplayMs = Math.round(now() - pendingReplayAt);
+        pendingReplayAt = null;
+        performance.mark('replay:speech-start');
+      }
     } else if (name === 'speech-end') {
-      speaking = false;
+      state.speaking = false;
       micInstance.noteSpeechEnd();
     } else if (name === 'asr-tier' && data) {
       state.asrTier = data.tier ?? null;
@@ -104,51 +155,163 @@ export function createTurnLoop({
     }
   }
 
+  function busyReason() {
+    if (state.thinking) return 'the avatar is still thinking about the last turn';
+    if (state.speaking) return 'the avatar is still speaking';
+    return null;
+  }
+
+  function fail(where, err) {
+    const message = String(err?.message ?? err);
+    state.lastError = message;
+    emit('error', { message, where });
+    return err instanceof Error ? err : new Error(message);
+  }
+
+  /**
+   * One turn: text in, speech out. Resolves at speech-end with a summary of the turn.
+   *
+   * Order matters and is asserted statically: the thinking pose engages BEFORE the
+   * first await, because switching the pose when the response arrives would forfeit
+   * the entire latency the pose exists to cover.
+   *
+   * @param {string} text        what the avatar should say back
+   * @param {object} [opts]
+   * @param {number} [opts.speed=1.0]  VOICEVOX speedScale; SLOWER_SPEED for the re-read
+   * @param {boolean} [opts.greeting]  ignore text and speak the server's fixed greeting
+   */
+  async function dispatchTurn(text, { speed = 1.0, greeting = false } = {}) {
+    const busy = busyReason();
+    if (busy) throw fail('dispatchTurn', new Error(busy));
+
+    const bridge = getServer();
+    if (!bridge || typeof bridge.turn !== 'function') {
+      throw fail(
+        'dispatchTurn',
+        new Error('no host bridge: the standalone stage has nothing to synthesise with')
+      );
+    }
+
+    performance.mark('turn:dispatch');
+    const dispatchedAt = now();
+    pendingDispatchAt = dispatchedAt;
+    setThinking(true);
+    emit('turn-start', { text: greeting ? null : text, speed, greeting });
+
+    try {
+      const directive = greeting
+        ? await bridge.greeting()
+        : await bridge.turn({ text: String(text ?? ''), speed });
+      performance.mark('turn:response');
+      const responseMs = Math.round(now() - dispatchedAt);
+
+      // The host's client swallows an HTTP error into `undefined`, and the far side
+      // answers a bad request with {error} rather than raising, so both are checked.
+      if (directive === undefined || directive === null) {
+        throw new Error('the host returned nothing for this turn - see its log');
+      }
+      if (directive.error) throw new Error(directive.error);
+      if (!directive.audio_url || !Array.isArray(directive.timeline)) {
+        throw new Error('the host returned a directive with no audio or no timeline');
+      }
+
+      state.turnCount += 1;
+      state.lastTurnId = directive.turn_id ?? null;
+      state.lastSubtitle = directive.subtitle ?? null;
+      state.lastSpeed = directive.speed ?? speed;
+      state.lastStageTimings = directive.timings ?? null;
+      state.lastError = null;
+      emit('turn', {
+        turnId: state.lastTurnId,
+        subtitle: state.lastSubtitle,
+        speed: state.lastSpeed,
+        timings: state.lastStageTimings,
+        responseMs,
+        greeting,
+      });
+
+      // Resolves at speech-end. speech-start arrives through observe() on the way.
+      const played = await stagePort.speak({
+        audioUrl: directive.audio_url,
+        timeline: directive.timeline,
+        subtitle: directive.subtitle,
+        expression: directive.expression,
+        turnId: directive.turn_id,
+      });
+
+      return {
+        turnId: state.lastTurnId,
+        subtitle: state.lastSubtitle,
+        speed: state.lastSpeed,
+        timings: state.lastStageTimings,
+        responseMs,
+        lastTurnMs: state.lastTurnMs,
+        duration: played?.duration ?? null,
+      };
+    } catch (err) {
+      pendingDispatchAt = null;
+      setThinking(false);
+      throw fail('dispatchTurn', err);
+    }
+  }
+
   return {
     state,
     getServer,
     observe,
     mic: micInstance,
     asr: asrInstance,
-
-    setThinking(value) {
-      const on = !!value;
-      state.thinking = on;
-      stagePort.setThinking(on);
-      return on;
-    },
-
-    setListening(value) {
-      const on = !!value;
-      state.listening = on;
-      stagePort.setListening(on);
-      return on;
-    },
+    setThinking,
+    setListening,
+    dispatchTurn,
 
     /**
      * Re-play the cached directive. There is deliberately no network access of any
-     * kind in here: plan 01-09's test_replay asserts zero requests with a browser
-     * request listener, and a cache miss must fail rather than quietly re-download.
+     * kind in here: the deployed suite asserts zero requests with a browser request
+     * listener, and a cache miss must fail rather than quietly re-download. The stage
+     * keeps the decoded AudioBuffer and the timeline it last spoke.
      */
     async replay() {
+      const busy = busyReason();
+      if (busy) throw fail('replay', new Error(busy));
+      if (state.turnCount === 0) throw fail('replay', new Error('nothing has been said yet'));
       state.replayCount += 1;
+      performance.mark('replay:dispatch');
+      pendingReplayAt = now();
+      emit('replay', { turnId: state.lastTurnId, subtitle: state.lastSubtitle });
       try {
         return await stagePort.replayCached();
       } catch (err) {
-        emit('error', { message: String(err?.message ?? err), where: 'replay' });
-        throw err;
+        pendingReplayAt = null;
+        throw fail('replay', err);
+      }
+    },
+
+    /**
+     * Re-synthesise the last utterance at SLOWER_SPEED. This IS a host round trip and
+     * must be: the timeline has to be rebuilt from the re-synthesised query, because
+     * speedScale divides every phoneme and a timeline scaled here would drift by exactly
+     * the speed ratio against the new audio.
+     */
+    async requestSlower() {
+      if (!state.lastSubtitle) {
+        throw fail('requestSlower', new Error('nothing to slow down yet - say something first'));
       }
+      return dispatchTurn(state.lastSubtitle, { speed: SLOWER_SPEED });
     },
 
     /**
-     * pointerdown on the push-to-talk control. Plan 01-08 wires the control itself;
-     * the behaviour is here so both transports get it from one implementation.
+     * pointerdown on the push-to-talk control. The host binds the control; the behaviour
+     * is here so both transports get it from one implementation.
      *
      * @returns {Promise<boolean>} whether capture actually started
      */
     async startListening() {
       const started = await micInstance.start();
-      if (!started) state.micRejectedCount = micInstance.__debug.rejectedCount;
+      if (!started) {
+        state.micRejectedCount = micInstance.__debug.rejectedCount;
+        state.micLastRejectReason = micInstance.__debug.lastRejectReason;
+      }
       return started;
     },
 
@@ -163,13 +326,14 @@ export function createTurnLoop({
     async stopListening() {
       const utterance = await micInstance.stop();
       state.micRejectedCount = micInstance.__debug.rejectedCount;
+      state.micLastRejectReason = micInstance.__debug.lastRejectReason;
       if (!utterance.ok) return null;
 
       let result;
       try {
         result = await asrInstance.transcribe(utterance.samples, utterance.sampleRate);
       } catch (err) {
-        emit('error', { message: String(err?.message ?? err), where: 'stopListening' });
+        fail('stopListening', err);
         return null;
       }
 
@@ -183,6 +347,7 @@ export function createTurnLoop({
           result.text ? REJECT.HALLUCINATION : REJECT.NO_AUDIO
         );
         state.micRejectedCount = micInstance.__debug.rejectedCount;
+        state.micLastRejectReason = micInstance.__debug.lastRejectReason;
         return null;
       }
 
@@ -195,8 +360,5 @@ export function createTurnLoop({
       });
       return result.text;
     },
-
-    dispatchTurn: notWiredYet('dispatchTurn', '01-08'),
-    requestSlower: notWiredYet('requestSlower', '01-08'),
   };
 }

avatar/vrm-stage.js

@@ -150,6 +150,13 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
     // -1 is straight down, 0 is the T-pose, +1 is straight up. Tests assert on this so
     // a regression to the T-pose fails a number instead of needing an eyeball.
     armDown: { left: 0, right: 0 },
+    // The thinking pose, as a viewer would see it: how far the head looks down (the
+    // world-space forward direction's downward component, ~sin THINK_TILT while
+    // thinking, ~0 otherwise, +/- the breath) and the 'relaxed' expression weight.
+    // Published so the pose is a number a test can assert, not a flag that says it was
+    // requested - the arms taught this project that those are different things.
+    headPitch: 0,
+    relaxedValue: 0,
     clockOffset: 0,
     thinking: false,
     listening: false,
@@ -191,7 +198,8 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
   };
   const shoulderPos = new THREE.Vector3();
   const elbowPos = new THREE.Vector3();
-  function measureArms() {
+  const headForward = new THREE.Vector3();
+  function measurePose() {
     for (const side of ['left', 'right']) {
       const [upper, lower] = armPairs[side];
       if (!upper || !lower) continue;
@@ -201,6 +209,14 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
       const len = dir.length();
       debug.armDown[side] = len > 0 ? dir.y / len : 0;
     }
+    // The normalized head bone is world-aligned at rest (+Z forward for every VRM), and
+    // three-vrm copies it onto the raw bone every update, so its world forward after a
+    // render is the direction the rendered face points. A positive pitch looks down.
+    if (head) {
+      head.getWorldDirection(headForward);
+      debug.headPitch = -headForward.y;
+    }
+    debug.relaxedValue = vrm.expressionManager?.getValue('relaxed') ?? 0;
   }
 
   const clock = new THREE.Clock();
@@ -267,7 +283,7 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
     if (onTick) onTick(dt);
     vrm.update(dt); // MUST run after expression values are set, every frame
     renderer.render(scene, camera);
-    measureArms();
+    measurePose();
   });
 
   const ro = new ResizeObserver(() => {

src/japanese_avatar/ui/avatar_component.py

@@ -27,11 +27,12 @@ VRM_URL = "/gradio_api/file=avatar/assets/tutor.vrm"
 # The IIFE also escapes Gradio's own try/catch, so it carries its own .catch: a boot
 # failure must reach the console, because that console line is plan 01-05's verdict.
 #
-# The status-line writes live HERE, in the shared boot template, rather than inside
-# avatar.js. Both transports run this same string in the host document, so the loading
-# state is symmetric by construction - putting it in avatar.js would have given the
-# inline transport a status line and the iframe fallback none, which is exactly the
-# drift the seam exists to prevent.
+# The status-line writes and the control bindings live HERE (via avatar/host.js), in the
+# shared boot template, rather than inside avatar.js. Both transports run this same
+# string in the host document, so the loading state and every control are symmetric by
+# construction - putting them in avatar.js would have given the inline transport a
+# working page and the iframe fallback an inert one, which is exactly the drift the seam
+# exists to prevent.
 #
 # Note what is NOT awaited before the stage mounts: nothing on the Python side. The
 # VRM is client-side, so it paints and starts breathing on its own schedule. On a
@@ -45,8 +46,11 @@ _BOOT_JS = """
             if (el) el.textContent = text;
         }};
         const m = await import('/gradio_api/file=avatar/{module}');
-        await m.boot(element, props, trigger, server);
-        status('ready - the avatar is live. Voice conversation is not wired up yet.');
+        const avatar = await m.boot(element, props, trigger, server);
+        // The host glue: binds the page's controls to the facade and renders what it
+        // reports. Loaded here, after boot, from the SAME template for both transports.
+        const host = await import('/gradio_api/file=avatar/host.js');
+        host.bindHost(avatar, document);
         watch('value', () => m.onDirective(props.value));
     }})().catch((err) => {{
         console.error('avatar boot failed:', err);
@@ -102,10 +106,10 @@ _STATUS_HTML = '<div id="status-text" class="status-line">waking up...</div>'
 class StatusLine(gr.HTML):
     """The one-line "what is the avatar doing" readout, addressable as #status-line.
 
-    Plans 01-07 and 01-08 write listening / thinking / speaking states into it. It is
-    a component rather than a bare string in app.py so the elem_id and the inner
+    avatar/host.js writes the listening / thinking / speaking states into it. It is a
+    component rather than a bare string in the layout so the elem_id and the inner
     #status-text id are declared in exactly one place, next to the boot script that
-    writes to them.
+    loads the module which writes to them.
     """
 
     def __init__(self, **kwargs):

tests/e2e/test_avatar_loop.py

@@ -286,15 +286,20 @@ def test_no_remount(page, space_url, warm_space):
     before = read_debug(page)
     assert before["mountCount"] == 1, f"mountCount was already {before['mountCount']} at ready"
 
+    # The wave-5 controls. Send with an empty box is refused in the browser; a filled
+    # box submitted with Enter is a real turn through server_functions (the button is
+    # disabled while the avatar thinks and speaks, and Playwright's actionability wait
+    # absorbs that); the About accordion is a Gradio component toggle. Between them the
+    # host re-renders the right-hand column and the stage must not notice.
     for i in range(20):
         which = i % 3
         if which == 0:
-            page.click("#send")
+            page.click("#send-button")
         elif which == 1:
-            page.fill("#text-input textarea", f"こんにちは {i}")
-            page.click("#send")
+            page.fill("#text-input input", f"こんにちは {i}")
+            page.press("#text-input input", "Enter")
         else:
-            page.locator("#slower input[type=checkbox]").click()
+            page.locator("#about-panel button").first.click()
         page.wait_for_timeout(250)
 
     debug = read_debug(page)

tests/e2e/test_facade_parity.py

@@ -1,19 +1,29 @@
-"""Mechanical proof that the two transports expose the same object.
+"""Mechanical proof that the two transports expose the same object - and the same turn.
 
 The static tests in tests/test_transport_seam.py can only prove that no transport
 *writes* window.Avatar. These boot the real Gradio app twice - once per
 AVATAR_TRANSPORT value - and compare the LIVE objects, which is the only way to catch
 a method that resolves in one transport and silently does not in the other.
 
-Marked slow but NOT deployed: they run entirely locally and must be green before
-plan 01-05 deploys anything.
+Since wave 5 the same fixture also drives a real turn through each transport: text in,
+synthesised speech out, thinking pose engaged in between, then a networkless replay and
+a slower re-read. Those are the local rehearsal, at the same thresholds, of the deployed
+rows plan 01-09 binds (test_text_turn, test_thinking_state, test_replay, test_slower),
+run under BOTH transports so a spike reversal could never cost the turn loop.
+
+Marked slow but NOT deployed: they run entirely locally.
 """
 
 from __future__ import annotations
 
 import pytest
 
-from tests.e2e.test_stage_standalone import ARM_DOWN_MAX, FIRST_FRAME_TIMEOUT_MS
+from tests.e2e.test_stage_standalone import (
+    ARM_DOWN_MAX,
+    FIRST_FRAME_TIMEOUT_MS,
+    HEAD_PITCH_IDLE_MAX,
+    HEAD_PITCH_THINKING_MIN,
+)
 from tests.test_transport_seam import avatar_surface
 
 pytestmark = pytest.mark.slow
@@ -21,6 +31,15 @@ pytestmark = pytest.mark.slow
 TRANSPORTS = ("inline", "iframe")
 AVATAR_READY = "() => !!window.Avatar && !!window.Avatar.__debug && window.Avatar.__debug.ready"
 BOOT_TIMEOUT_MS = 120_000
+TURN_TIMEOUT_MS = 120_000
+
+# こんにちは: the golden fixture sentence, so the viseme sequence and the slow/normal
+# ratio are already pinned by the unit suite (tests/test_directive.py).
+TURN_TEXT = "こんにちは"
+SLOWER_SPEED = 0.75
+# The realised ratio is near 1/0.75, never exactly on it (VOICEVOX re-quantises after
+# dividing); 5% is the deployed band plan 01-09 uses, so the rehearsal matches it.
+SLOWER_RATIO_TOLERANCE = 0.05
 
 # The pose is measured after a render, and ready fires before the first one. Same
 # frame-rendered signal as the standalone suite, read through the facade because the
@@ -32,60 +51,191 @@ async () => {
 }
 """
 
-# Deliberately double-quoted and built from data: the surface list must come from
-# facade.js, never from a literal in this file.
-#
-# This tuple shrinks as waves land. Plan 01-07 implemented startListening/stopListening,
-# so they moved OUT of here and into WIRED_METHODS below; only plan 01-08's two remain.
-# The test itself is not deleted until the tuple is empty - a deferred stub that has
-# quietly become a no-op is exactly the drift this suite exists to catch.
-DEFERRED_PLAN = "01-08"
-DEFERRED_METHODS = ("dispatchTurn", "requestSlower")
-
-# Implemented and expected to work under BOTH transports.
-WIRED_PLAN = "01-07"
-WIRED_METHODS = ("startListening", "stopListening")
-
-CALL_DEFERRED = """
-async (name) => {
+# Type check plus a real call, for EVERY name in the surface. A method that exists but
+# still throws the not-wired error would pass a typeof check and fail a learner, so both
+# halves are needed. Called with no arguments: most reject for an ordinary reason (no
+# text, nothing cached, no microphone), and that is fine - only the deferred-stub error
+# is a failure. mount is excluded from the call because a second mount is exactly the
+# remount AVTR-01 forbids; its type is still checked.
+PROBE_SURFACE = """
+async (names) => {
+  const out = {};
+  for (const name of names) {
+    const isFunction = typeof window.Avatar[name] === 'function';
+    let notWired = false;
+    let message = '';
+    if (isFunction && name !== 'mount') {
+      try {
+        await window.Avatar[name]();
+      } catch (err) {
+        message = String((err && err.message) || err);
+        notWired = message.includes('not wired yet');
+      }
+    }
+    out[name] = { isFunction, notWired, message };
+  }
+  return out;
+}
+"""
+
+# One full text turn, observed the way a learner experiences it: thinking engages at
+# dispatch (before any await), the head visibly tilts while the server works, speech
+# starts, the mouth opens to distinct shapes, speech ends, thinking is long gone.
+# Everything is read through getDebug() per animation frame, never from the stale
+# __debug snapshot. Note that getDebug() resolves to the facade's LIVE merged object,
+# not a copy: every scalar is read out the moment it is sampled, because holding the
+# object and reading it later reads the final state.
+TURN_PROBE = """
+async ({ text, timeoutMs }) => {
+  const events = [];
+  const names = ['turn-start', 'turn', 'speech-start', 'speech-end', 'latency', 'error'];
+  const offs = names.map((n) =>
+    window.Avatar.on(n, (d) => events.push({ name: n, at: performance.now(), data: d ?? null }))
+  );
+  const t0 = performance.now();
+  const turn = window.Avatar.dispatchTurn(text);
+  const immediateThinking = (await window.Avatar.getDebug()).thinking;
+  const immediateAt = performance.now();
+
+  let maxHeadPitch = -1;
+  let maxRelaxed = 0;
+  let thinkingSamples = 0;
+  let samples = 0;
+  let thinkingAtSpeechStart = null;
+  while (!events.some((e) => e.name === 'speech-start') && performance.now() - t0 < timeoutMs) {
+    const d = await window.Avatar.getDebug();
+    samples += 1;
+    if (d.thinking) {
+      thinkingSamples += 1;
+      maxHeadPitch = Math.max(maxHeadPitch, d.headPitch);
+      maxRelaxed = Math.max(maxRelaxed, d.relaxedValue);
+    }
+    await new Promise((r) => requestAnimationFrame(r));
+  }
+  thinkingAtSpeechStart = (await window.Avatar.getDebug()).thinking;
+
+  let result = null;
+  let error = null;
+  try {
+    result = await turn;
+  } catch (err) {
+    error = String((err && err.message) || err);
+  }
+  // speak() resolves at speech-end, while the player is still cross-fading the mouth
+  // shut (a 50 ms attack); give it up to 2 s of frames to settle, as the standalone
+  // suite does, then read the final state.
+  const settledBy = performance.now() + 2000;
+  let after = await window.Avatar.getDebug();
+  while (
+    performance.now() < settledBy &&
+    Object.values(after.currentVisemes).some((v) => v !== 0)
+  ) {
+    await new Promise((r) => requestAnimationFrame(r));
+    after = await window.Avatar.getDebug();
+  }
+  for (const off of offs) off();
+  return {
+    error,
+    result,
+    immediateThinking,
+    immediateMs: Math.round(immediateAt - t0),
+    thinkingSamples,
+    samples,
+    maxHeadPitch,
+    maxRelaxed,
+    thinkingAtSpeechStart,
+    events: events.map((e) => ({
+      name: e.name,
+      at: Math.round(e.at - t0),
+      duration: e.data && typeof e.data.duration === 'number' ? e.data.duration : null,
+    })),
+    after: {
+      thinking: after.thinking,
+      speaking: after.speaking,
+      headPitch: after.headPitch,
+      turnCount: after.turnCount,
+      lastSubtitle: after.lastSubtitle,
+      lastSpeed: after.lastSpeed,
+      lastTurnMs: after.lastTurnMs,
+      lastStageTimings: after.lastStageTimings,
+      visemePeaks: after.visemePeaks,
+      currentVisemes: after.currentVisemes,
+      transport: after.transport,
+    },
+  };
+}
+"""
+
+REPLAY_PROBE = """
+async () => {
+  const events = [];
+  const off = window.Avatar.on('speech-end', (d) => events.push(d));
+  const before = await window.Avatar.getDebug();
+  let error = null;
   try {
-    await window.Avatar[name]('x');
-    return { threw: false, message: '' };
+    await window.Avatar.replay();
   } catch (err) {
-    return { threw: true, message: String((err && err.message) || err) };
+    error = String((err && err.message) || err);
   }
+  const after = await window.Avatar.getDebug();
+  off();
+  return {
+    error,
+    speechEnds: events.length,
+    duration: events[0] ? events[0].duration : null,
+    turnCountBefore: before.turnCount,
+    turnCountAfter: after.turnCount,
+    replayCount: after.replayCount,
+    lastReplayMs: after.lastReplayMs,
+  };
 }
 """
 
-# Type check plus a real call. A method that exists but still throws the not-wired error
-# would pass a typeof check and fail a learner, so both halves are needed.
-PROBE_WIRED = """
-async (name) => {
-  const isFunction = typeof window.Avatar[name] === 'function';
-  let notWired = false;
-  let message = '';
+SLOWER_PROBE = """
+async () => {
+  let error = null;
+  let result = null;
   try {
-    await window.Avatar[name]();
+    result = await window.Avatar.requestSlower();
   } catch (err) {
-    message = String((err && err.message) || err);
-    notWired = message.includes('not wired yet');
+    error = String((err && err.message) || err);
   }
-  return { isFunction, notWired, message };
+  const after = await window.Avatar.getDebug();
+  return {
+    error,
+    result,
+    turnCount: after.turnCount,
+    lastSpeed: after.lastSpeed,
+    lastSubtitle: after.lastSubtitle,
+    lastStageTimings: after.lastStageTimings,
+    visemePeaks: after.visemePeaks,
+  };
 }
 """
 
 
+def _wait_settled(page):
+    """The controls re-arm 200 ms after speech-end; a follow-on call must not race that."""
+    page.wait_for_function(
+        "async () => { const d = await window.Avatar.getDebug(); "
+        "return !d.thinking && !d.speaking; }",
+        timeout=TURN_TIMEOUT_MS,
+    )
+    page.wait_for_timeout(300)
+
+
 @pytest.fixture(scope="session")
 def live_avatars(browser, gradio_apps):
-    """Boot each transport once and capture everything the three tests compare."""
+    """Boot each transport once and capture everything the tests compare."""
     captured = {}
     for transport in TRANSPORTS:
         url = gradio_apps(transport)
         page = browser.new_page()
+        requests: list[str] = []
         try:
             page.goto(url)
             page.wait_for_function(AVATAR_READY, timeout=BOOT_TIMEOUT_MS)
-            captured[transport] = {
+            record = {
                 "surface": page.evaluate(
                     "() => Object.keys(window.Avatar).filter(k => k !== '__debug').sort()"
                 ),
@@ -93,18 +243,42 @@ def live_avatars(browser, gradio_apps):
                     "async () => Object.keys(await window.Avatar.getDebug()).sort()"
                 ),
                 "reported_transport": page.evaluate("() => window.Avatar.__debug.transport"),
-                "deferred": {name: page.evaluate(CALL_DEFERRED, name) for name in DEFERRED_METHODS},
-                "wired": {name: page.evaluate(PROBE_WIRED, name) for name in WIRED_METHODS},
+                "probe": page.evaluate(PROBE_SURFACE, avatar_surface()),
             }
             page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
-            captured[transport]["arm_down"] = page.evaluate(
+            record["arm_down"] = page.evaluate(
                 "async () => (await window.Avatar.getDebug()).armDown"
             )
+            record["idle_head_pitch"] = page.evaluate(
+                "async () => (await window.Avatar.getDebug()).headPitch"
+            )
+
+            # The turn. Runs even where synthesis is unavailable; the turn tests then
+            # skip on the recorded error rather than the whole parity suite failing.
+            record["turn"] = page.evaluate(
+                TURN_PROBE, {"text": TURN_TEXT, "timeoutMs": TURN_TIMEOUT_MS}
+            )
+            if record["turn"]["error"] is None:
+                _wait_settled(page)
+                page.on("request", lambda r, sink=requests.append: sink(r.url))
+                record["replay"] = page.evaluate(REPLAY_PROBE)
+                record["replay_requests"] = list(requests)
+                _wait_settled(page)
+                record["slower"] = page.evaluate(SLOWER_PROBE)
+            captured[transport] = record
         finally:
             page.close()
     return captured
 
 
+def _turn_or_skip(live_avatars, transport):
+    turn = live_avatars[transport]["turn"]
+    if turn["error"] is not None:
+        pytest.importorskip("voicevox_core")
+        pytest.fail(f"{transport}: dispatchTurn rejected: {turn['error']}")
+    return turn
+
+
 def test_transports_expose_identical_surfaces(live_avatars):
     inline = live_avatars["inline"]["surface"]
     iframe = live_avatars["iframe"]["surface"]
@@ -129,6 +303,8 @@ def test_transports_expose_identical_debug_keys(live_avatars):
         "__debug has drifted between transports; symmetric difference "
         f"(inline ^ iframe) = {sorted(set(inline) ^ set(iframe))}"
     )
+    for key in ("lastTurnMs", "lastStageTimings", "lastSubtitle", "replayCount", "turnCount"):
+        assert key in inline, f"__debug.{key} is missing from the live object"
 
 
 def test_arms_rest_at_sides_under_both_transports(live_avatars):
@@ -148,38 +324,129 @@ def test_arms_rest_at_sides_under_both_transports(live_avatars):
             )
 
 
-def test_deferred_methods_fail_loudly_not_silently(live_avatars):
-    """The remaining stubs are placeholders, not accidental no-ops.
+def test_turn_surface_is_live_under_both_transports(live_avatars):
+    """Every name in AVATAR_SURFACE is a function and none is a deferred stub - on BOTH.
 
-    Scope shrinks with each wave rather than the test being deleted: plan 01-07 removed
-    startListening/stopListening from DEFERRED_METHODS when it implemented them, and plan
-    01-08 empties the tuple. Whatever is still deferred must still fail loudly.
+    This is the mechanical proof that a spike failure would not have cost VOIC-02/03/04/05:
+    the iframe transport gained the whole turn loop without gaining a line of code, and
+    this asserts it against a LIVE object rather than against a grep. It replaces the
+    deferred-stub guard that shrank wave by wave and is empty now.
     """
     for transport in TRANSPORTS:
-        for name, outcome in live_avatars[transport]["deferred"].items():
-            assert outcome["threw"], (
-                f"{transport}: Avatar.{name}() returned instead of throwing; a silent "
-                "no-op is exactly what the deferred stubs exist to prevent"
+        for name, outcome in live_avatars[transport]["probe"].items():
+            assert outcome["isFunction"], (
+                f"{transport}: Avatar.{name} is not a function; the shared turn loop did "
+                "not reach this transport"
             )
-            assert DEFERRED_PLAN in outcome["message"], (
-                f"{transport}: Avatar.{name}() threw {outcome['message']!r}, which does "
-                f"not name plan {DEFERRED_PLAN}"
+            assert not outcome["notWired"], (
+                f"{transport}: Avatar.{name}() still throws a not-wired error: "
+                f"{outcome['message']!r}"
             )
 
 
-def test_push_to_talk_exists_under_both_transports(live_avatars):
-    """The payoff of putting the wiring in avatar/turn-loop.js.
+def test_text_turn_speaks_under_both_transports(live_avatars):
+    """VOIC-04 rehearsal: text in, speech-start then speech-end, the mouth actually moved."""
+    for transport in TRANSPORTS:
+        turn = _turn_or_skip(live_avatars, transport)
+        names = [e["name"] for e in turn["events"]]
+        print(f"[{transport}] turn events: {turn['events']}")
+        print(f"[{transport}] after: {turn['after']}")
+
+        assert "turn-start" in names and "turn" in names, names
+        assert "speech-start" in names and "speech-end" in names, (
+            f"{transport}: the turn never produced speech: {names}"
+        )
+        assert names.index("speech-start") < names.index("speech-end")
+        assert "error" not in names, [e for e in turn["events"] if e["name"] == "error"]
+
+        after = turn["after"]
+        assert after["transport"] == transport
+        assert after["turnCount"] == 1
+        assert after["lastSubtitle"] == TURN_TEXT
+        assert after["lastSpeed"] == 1.0
+        assert not after["speaking"]
+        # The number that matters, and the server breakdown that travelled with it.
+        assert isinstance(after["lastTurnMs"], int | float) and after["lastTurnMs"] > 0
+        assert set(after["lastStageTimings"]) >= {
+            "audio_query_ms",
+            "synthesis_ms",
+            "timeline_ms",
+            "encode_ms",
+            "server_total_ms",
+        }
+        assert after["lastStageTimings"]["synthesis_ms"] > 0
+        # こんにちは drives o, i, i, a: three distinct shapes, not one flap.
+        peaks = after["visemePeaks"]
+        opened = [n for n in ("aa", "ih", "oh") if peaks.get(n, 0) > 0.5]
+        assert len(opened) == 3, f"{transport}: only {opened} opened; peaks {peaks}"
+        assert all(v == 0 for v in after["currentVisemes"].values()), (
+            f"{transport}: the mouth did not shut after speech-end: {after['currentVisemes']}"
+        )
 
-    The iframe transport gained push-to-talk without gaining a line of code, and this is
-    the assertion that proves it against a LIVE object rather than against a grep.
+
+def test_thinking_state_under_both_transports(live_avatars):
+    """VOIC-05 rehearsal: thinking engages at dispatch and clears at speech-start.
+
+    Asserted as numbers at this layer too: `thinking` is true on the first getDebug()
+    after dispatch, the head is measurably pitched down while it is true, and it is
+    false by the time speech starts and stays false afterwards.
     """
     for transport in TRANSPORTS:
-        for name, outcome in live_avatars[transport]["wired"].items():
-            assert outcome["isFunction"], (
-                f"{transport}: Avatar.{name} is not a function; the shared turn loop did "
-                "not reach this transport"
-            )
-            assert not outcome["notWired"], (
-                f"{transport}: Avatar.{name}() still throws the plan {WIRED_PLAN} "
-                f"not-wired error: {outcome['message']!r}"
-            )
+        turn = _turn_or_skip(live_avatars, transport)
+        print(
+            f"[{transport}] thinking: immediate={turn['immediateThinking']} "
+            f"({turn['immediateMs']} ms after dispatch), {turn['thinkingSamples']}/"
+            f"{turn['samples']} frames thinking, maxHeadPitch={turn['maxHeadPitch']:.3f}, "
+            f"maxRelaxed={turn['maxRelaxed']}, idleHeadPitch="
+            f"{live_avatars[transport]['idle_head_pitch']:.3f}"
+        )
+        assert turn["immediateThinking"] is True, (
+            f"{transport}: thinking was not true on the first getDebug() after dispatch "
+            f"({turn['immediateMs']} ms later)"
+        )
+        assert turn["thinkingSamples"] > 0
+        assert turn["maxHeadPitch"] > HEAD_PITCH_THINKING_MIN, (
+            f"{transport}: the head never pitched down while thinking "
+            f"(max {turn['maxHeadPitch']:.3f}); the pose was requested but not rendered"
+        )
+        assert turn["maxRelaxed"] > 0
+        assert turn["thinkingAtSpeechStart"] is False, (
+            f"{transport}: thinking was still true when speech started"
+        )
+        assert turn["after"]["thinking"] is False
+        assert abs(turn["after"]["headPitch"]) < HEAD_PITCH_IDLE_MAX
+        assert abs(live_avatars[transport]["idle_head_pitch"]) < HEAD_PITCH_IDLE_MAX
+
+
+def test_replay_is_networkless_under_both_transports(live_avatars):
+    """VOIC-03 rehearsal: replay re-plays the cached buffer with zero requests."""
+    for transport in TRANSPORTS:
+        _turn_or_skip(live_avatars, transport)
+        replay = live_avatars[transport]["replay"]
+        requests = live_avatars[transport]["replay_requests"]
+        print(f"[{transport}] replay: {replay}; requests during replay: {requests}")
+        assert replay["error"] is None, f"{transport}: replay rejected: {replay['error']}"
+        assert replay["speechEnds"] == 1
+        assert replay["replayCount"] == 1
+        assert replay["turnCountAfter"] == replay["turnCountBefore"], "a replay is not a turn"
+        assert requests == [], f"{transport}: replay made network requests: {requests}"
+        assert replay["lastReplayMs"] is not None and replay["lastReplayMs"] < 1000
+
+
+def test_slower_resynthesises_under_both_transports(live_avatars):
+    """VOIC-03 rehearsal: the slow re-read is longer audio from a real re-synthesis."""
+    for transport in TRANSPORTS:
+        turn = _turn_or_skip(live_avatars, transport)
+        slower = live_avatars[transport]["slower"]
+        assert slower["error"] is None, f"{transport}: requestSlower rejected: {slower['error']}"
+        normal = turn["result"]["duration"]
+        slow = slower["result"]["duration"]
+        ratio = slow / normal
+        print(f"[{transport}] slower: normal {normal:.3f}s, slow {slow:.3f}s, ratio {ratio:.4f}")
+
+        assert slower["turnCount"] == 2, "slower is a turn - it must round-trip to the server"
+        assert slower["lastSpeed"] == SLOWER_SPEED
+        assert slower["lastSubtitle"] == TURN_TEXT
+        assert abs(ratio - 1 / SLOWER_SPEED) < SLOWER_RATIO_TOLERANCE * (1 / SLOWER_SPEED), ratio
+        assert slower["lastStageTimings"]["synthesis_ms"] > 0, "not re-synthesised server-side"
+        assert any(v > 0.4 for v in slower["visemePeaks"].values())

tests/e2e/test_stage_standalone.py

@@ -24,6 +24,13 @@ STAGE_READY = "() => !!window.__stageDebug && window.__stageDebug.ready === true
 # idle sway. Shared verbatim with the deployed suite.
 ARM_DOWN_MAX = -0.7
 
+# headPitch is the downward component of the head's world-space forward direction:
+# ~sin(THINK_TILT) = 0.08 while thinking, ~0 at rest, plus or minus the 0.012 rad breath.
+# 0.05 / 0.03 leave the breath a comfortable margin on both sides. Shared with the parity
+# suite so the three layers assert the same numbers.
+HEAD_PITCH_THINKING_MIN = 0.05
+HEAD_PITCH_IDLE_MAX = 0.03
+
 # `ready` is announced before the first frame renders, and the first frame compiles every
 # MToon shader - measured at over 1.5 s on the headless fleet - so the debug snapshot can
 # still hold its boot-time zeros well after ready. breathValue is written on every tick and
@@ -210,3 +217,42 @@ def test_console_has_no_multiple_three_warning(page, static_server):
 
     offenders = [m for m in messages if "Multiple instances of Three.js" in m]
     assert not offenders, f"three.js reported duplicate instances: {offenders}"
+
+
+def test_thinking_pose_is_visible(page, static_server):
+    """VOIC-05's thinking state, as a rendered number rather than a flag.
+
+    The standalone harness has no server, so it cannot dispatch a turn - but the pose
+    the turn engages is a stage property, and the harness answers the same postMessage
+    protocol the iframe transport speaks, from its own window. setThinking(true) must
+    pitch the rendered head down and raise the 'relaxed' expression; setThinking(false)
+    must return both to rest. A flag that says "thinking" with no visible change is the
+    T-pose lesson again.
+    """
+    _open_stage(page, static_server)
+    page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
+    rest = page.evaluate("() => window.__stageDebug.headPitch")
+    assert abs(rest) < HEAD_PITCH_IDLE_MAX, f"head pitched {rest:.3f} at rest"
+
+    page.evaluate(
+        "() => window.postMessage({ type: 'avatar:setThinking', value: true, id: 'think' }, '*')"
+    )
+    page.wait_for_function(
+        f"() => window.__stageDebug.headPitch > {HEAD_PITCH_THINKING_MIN}", timeout=5_000
+    )
+    thinking = page.evaluate(
+        "() => ({ headPitch: window.__stageDebug.headPitch, "
+        "relaxed: window.__stageDebug.relaxedValue, flag: window.__stageDebug.thinking })"
+    )
+    print(f"[standalone] thinking pose: {thinking}")
+    assert thinking["flag"] is True
+    assert thinking["relaxed"] > 0
+
+    page.evaluate(
+        "() => window.postMessage({ type: 'avatar:setThinking', value: false, id: 'idle' }, '*')"
+    )
+    page.wait_for_function(
+        f"() => Math.abs(window.__stageDebug.headPitch) < {HEAD_PITCH_IDLE_MAX}", timeout=5_000
+    )
+    assert page.evaluate("() => window.__stageDebug.relaxedValue") == 0
+    assert page.evaluate("() => window.__stageDebug.thinking") is False

tests/test_transport_seam.py

@@ -24,6 +24,11 @@ TURN_SURFACE = ["startListening", "stopListening", "dispatchTurn", "requestSlowe
 # only rendering and audio playback live inside the iframe - so these modules must hang
 # off the shared turn loop, never off a transport.
 AUDIO_IN = ["mic.js", "asr.js"]
+# Wave 5. The host glue binds the page's controls to window.Avatar. It is loaded by the
+# shared boot template in avatar_component.py, so both transports get the same controls;
+# it must import no avatar module, be imported by none, and implement no turn behaviour.
+HOST = "host.js"
+COMPONENT = AVATAR.parent / "src" / "japanese_avatar" / "ui" / "avatar_component.py"
 
 
 def src(name: str) -> str:
@@ -269,3 +274,68 @@ def test_transports_gained_push_to_talk_without_gaining_code(name):
         assert token not in s, (
             f"{name} mentions {token!r}; push-to-talk must live only in avatar/turn-loop.js"
         )
+
+
+@pytest.mark.parametrize("member", ["dispatchTurn", "requestSlower"])
+def test_turn_dispatch_is_implemented_not_deferred(member):
+    """The wave-5 methods are real, and nothing in the file is a deferred stub any more."""
+    s = src("turn-loop.js")
+    assert "notWiredYet" not in s, "a deferred stub survives in avatar/turn-loop.js"
+    assert f"{member}(" in s, f"{member} must be implemented in avatar/turn-loop.js"
+
+
+def test_thinking_engages_before_the_first_await():
+    """VOIC-05's cheapest latency mitigation: the pose switches at dispatch, not at response.
+
+    Verified by line number inside dispatchTurn: setThinking(true) precedes the first
+    await, which is the server call.
+    """
+    lines = src("turn-loop.js").splitlines()
+    start = next(i for i, line in enumerate(lines) if "async function dispatchTurn(" in line)
+    body = lines[start:]
+    think_at = next(i for i, line in enumerate(body) if "setThinking(true)" in line)
+    await_at = next(i for i, line in enumerate(body) if "await " in line)
+    assert think_at < await_at, (
+        f"setThinking(true) is on dispatchTurn line {think_at} but the first await is on "
+        f"line {await_at}; the thinking pose must engage before the server round trip"
+    )
+    assert "await bridge." in body[await_at], body[await_at]
+
+
+def test_replay_is_networkless_by_construction():
+    """replay() re-emits the cached buffer. No fetch, no dynamic import, anywhere in the loop."""
+    s = src("turn-loop.js")
+    assert "fetch(" not in s
+    assert "import(" not in s
+    assert "XMLHttpRequest" not in s
+
+
+def test_turn_loop_publishes_the_latency_numbers():
+    s = src("turn-loop.js")
+    for key in ("lastTurnMs", "lastStageTimings", "lastSubtitle", "replayCount", "turnCount"):
+        assert f"{key}:" in s, f"__debug.{key} is not initialised in avatar/turn-loop.js"
+    for mark in ("turn:dispatch", "turn:response", "turn:speech-start"):
+        assert f"performance.mark('{mark}')" in s, f"performance.mark({mark!r}) missing"
+    assert "0.75" in s, "the slower speed must be the VOICEVOX speedScale 0.75"
+    assert "greeting" in s
+
+
+def test_host_glue_is_neither_a_transport_nor_the_turn_loop():
+    """host.js is page glue: loaded from the shared boot template, importing nothing here."""
+    host = src(HOST)
+    assert not re.search(r"^\s*import\s", host, re.M), (
+        "host.js must not import any avatar module; it is handed the facade"
+    )
+    for member in TURN_SURFACE:
+        assert f"function {member}" not in host and f"async {member}(" not in host, (
+            f"host.js implements {member}; turn behaviour belongs in avatar/turn-loop.js"
+        )
+    for member in ["dispatchTurn", "requestSlower", "replay", "startListening", "stopListening"]:
+        assert f".{member}(" in host, f"host.js never calls Avatar.{member}()"
+    for name in [*TRANSPORTS, *SHARED, *CORE, *AUDIO_IN]:
+        assert HOST not in src(name), f"{name} references {HOST}; only the boot template may"
+    component = COMPONENT.read_text(encoding="utf-8")
+    assert component.count(f"import('/gradio_api/file=avatar/{HOST}')") == 1, (
+        "the shared boot template must load host.js exactly once, for both transports"
+    )
+    assert "bindHost(avatar, document)" in component