fix(01-05): pose the arms out of the authored T-pose and assert it

A VRM's rest pose is a T-pose and nothing in the stage ever moved the arms,
so the deployed avatar stood with both arms straight out while every AVTR-01
check passed (docs/evidence/2026-09-05-deployed-tpose.png).

vrm-stage.js now rotates each upper arm 1.2 rad about Z toward the body and
the forearm a further 0.2 rad, once, on the normalized bones at mount. The
idle life only writes spine, hips and head, so the two never compete.

The pose is measured every frame on the RAW skeleton after render and
published as debug.armDown.{left,right}: the downward component of the
world-space shoulder->elbow direction (-1 down, 0 T-pose). Measured -0.932
both sides, which is sin(1.2) exactly.

Tests at all three layers assert armDown < -0.7 (ARM_DOWN_MAX): the
standalone stage, both Gradio transports through the facade (so the field
is proven to cross the iframe boundary), and the deployed Space. Each waits
for the first rendered frame via breathValue rather than a fixed sleep,
because the first frame compiles every MToon shader and was measured over
1.5 s on the headless fleet. Mutation-tested: with ARM_REST_DROP = 0 the
standalone test fails with armDown=0.000.

.planning/phases/01-voice-avatar-loop-skeleton/01-VALIDATION.md

@@ -93,9 +93,12 @@ the planner MUST bind each row to a task and the executor MUST fill in Status.
 ## Observable Signals
 
 The canvas is opaque — **never screenshot-diff the VRM.** The avatar must expose
-`window.Avatar.__debug = { ready, mountCount, vrmMetaTitle, threeInstanceCount, currentVisemes: {aa,ih,ou,ee,oh}, blinkValue, clockOffset }`
+`window.Avatar.__debug = { ready, mountCount, vrmMetaTitle, threeInstanceCount, currentVisemes: {aa,ih,ou,ee,oh}, visemePeaks, blinkValue, blinkCount, breathValue, armDown: {left,right}, clockOffset }`
 so every visual assertion becomes a numeric one.
 
+- **Rest pose:** `armDown.{left,right}` is the downward component of the world-space shoulder→elbow direction on the raw skeleton (-1 down, 0 T-pose). Assert `< -0.7` (`ARM_DOWN_MAX`). Added 2026-09-05 after the deployed avatar passed every AVTR-01 check while standing in a T-pose.
+- **Reading `__debug`:** it is a snapshot refreshed only by `getDebug()`. Always `await window.Avatar.getDebug()` per sample; polling `__debug` directly reads frozen values.
+
 - **Audio:** `speech-start` / `speech-end` custom events, `AudioContext.state`, `AudioBuffer.duration`. Duration ratios are the reliable proxy for "it actually spoke slower".
 - **Module identity:** `performance.getEntriesByType('resource').filter(e => e.name.includes('three.mjs')).length === 1`
 - **Latency:** `performance.mark`/`measure` names emitted per stage, scraped by the harness.

avatar/vrm-stage.js

@@ -27,6 +27,16 @@ const SWAY_HIPS = 0.02; // rad
 const THINK_TILT = 0.08; // rad
 const LISTEN_LEAN = 0.05; // rad
 
+// Rest pose. A VRM's authored rest pose IS a T-pose - both arms straight out along X -
+// and nothing about the idle life above moves the arms, so without this block the
+// avatar stands like a scarecrow on a page whose every other test is green. The upper
+// arm is rotated about Z toward the body (1.2 rad leaves it ~21 deg out from vertical,
+// a relaxed A-pose rather than pinned to the hip) and the forearm follows a little
+// further in. Applied ONCE to the normalized bones at mount; the idle life only ever
+// writes spine, hips and head, so the two never compete for a bone.
+const ARM_REST_DROP = 1.2; // rad about Z, sign per side
+const FOREARM_REST_DROP = 0.2; // rad about Z, sign per side
+
 /**
  * Copy only structured-cloneable scalars out of a VRM meta block.
  * `vrm.meta.thumbnailImage` is an HTMLImageElement, which cannot cross a frame
@@ -135,6 +145,11 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
     blinkValue: 0,
     blinkCount: 0,
     breathValue: 0,
+    // Downward component of each upper arm's world-space direction, read from the
+    // RAW skeleton the renderer skins (not the normalized rig the pose is written to):
+    // -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 },
     clockOffset: 0,
     thinking: false,
     listening: false,
@@ -152,6 +167,42 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
     cameraY: camera.position.y,
   };
 
+  // Bring the arms down out of the authored T-pose. Normalized bone axes are world-
+  // aligned at rest under both VRM 0.0 and 1.0, so the same signed Z rotation lowers
+  // the left arm (+X) and the right arm (-X) symmetrically.
+  for (const [side, sign] of [
+    ['left', -1],
+    ['right', 1],
+  ]) {
+    const upper = bone(`${side}UpperArm`);
+    const lower = bone(`${side}LowerArm`);
+    if (upper) upper.rotation.z = sign * ARM_REST_DROP;
+    if (lower) lower.rotation.z = sign * FOREARM_REST_DROP;
+  }
+
+  // Measure the pose the way a viewer sees it: the direction from shoulder to elbow in
+  // world space, on the raw bones that drive the mesh. Read after render, when the
+  // world matrices are current.
+  const rawBone = (name) =>
+    vrm.humanoid?.getRawBoneNode?.(name) ?? vrm.humanoid?.getNormalizedBoneNode?.(name) ?? null;
+  const armPairs = {
+    left: [rawBone('leftUpperArm'), rawBone('leftLowerArm')],
+    right: [rawBone('rightUpperArm'), rawBone('rightLowerArm')],
+  };
+  const shoulderPos = new THREE.Vector3();
+  const elbowPos = new THREE.Vector3();
+  function measureArms() {
+    for (const side of ['left', 'right']) {
+      const [upper, lower] = armPairs[side];
+      if (!upper || !lower) continue;
+      upper.getWorldPosition(shoulderPos);
+      lower.getWorldPosition(elbowPos);
+      const dir = elbowPos.sub(shoulderPos);
+      const len = dir.length();
+      debug.armDown[side] = len > 0 ? dir.y / len : 0;
+    }
+  }
+
   const clock = new THREE.Clock();
   let elapsed = 0;
   let nextBlinkAt = BLINK_MIN + Math.random() * BLINK_SPREAD;
@@ -216,6 +267,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();
   });
 
   const ro = new ResizeObserver(() => {
@@ -231,7 +283,11 @@ export async function mountStage(canvasEl, vrmUrl, emit = () => {}) {
     scene,
     camera,
     renderer,
-    getDebug: () => ({ ...debug, currentVisemes: { ...debug.currentVisemes } }),
+    getDebug: () => ({
+      ...debug,
+      currentVisemes: { ...debug.currentVisemes },
+      armDown: { ...debug.armDown },
+    }),
     setExpressionWeights(weights) {
       const em = vrm.expressionManager;
       for (const v of VISEME_NAMES) {

tests/e2e/test_avatar_loop.py

@@ -20,6 +20,8 @@ import time
 import pytest
 import requests
 
+from tests.e2e.test_stage_standalone import ARM_DOWN_MAX, FIRST_FRAME_TIMEOUT_MS
+
 # Applied at module scope AND per test. The module-level mark is the one that matters -
 # it cannot be forgotten on a test plan 01-09 adds later - while the per-test decorators
 # are what this plan's acceptance check counts. Re-applying the same mark is a no-op.
@@ -85,6 +87,16 @@ async (ms) => {
 }
 """
 
+# ready fires before the first frame renders and the first frame compiles every shader;
+# the pose is measured post-render, so wait for a tick to have happened. breathValue is
+# written every tick and is exactly 0 only before the first one.
+FIRST_FRAME = """
+async () => {
+  const d = window.Avatar ? await window.Avatar.getDebug() : null;
+  return !!d && d.breathValue !== 0;
+}
+"""
+
 # Resource timing for the VRM itself. Recorded rather than asserted: plan 01-10 reuses
 # it in docs/LATENCY.md, and a slow CDN is not a reason to fail the spike.
 VRM_TIMING = """
@@ -237,6 +249,30 @@ def test_idle_life(page, space_url, warm_space):
     )
 
 
+@pytest.mark.deployed
+def test_arms_at_sides(page, space_url, warm_space):
+    """AVTR-01. The deployed avatar stands with its arms down, as a number.
+
+    Revision 41ee90e passed test_vrm_ready and test_idle_life while standing in a full
+    T-pose (docs/evidence/2026-09-05-deployed-tpose.png): threeInstanceCount was 1, the
+    VRM had its meta, it blinked and breathed - and nothing had ever posed the arms. This
+    is the assertion that would have caught it. armDown is the downward component of the
+    world-space shoulder->elbow direction on the raw skeleton: 0 is the T-pose.
+    """
+    _open_ready(page, space_url)
+    page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
+    debug = read_debug(page)
+    arms = debug.get("armDown") if debug else None
+    print(f"[deployed] armDown={arms}")
+
+    assert arms is not None, "armDown is missing from the deployed debug surface"
+    for side in ("left", "right"):
+        assert arms[side] < ARM_DOWN_MAX, (
+            f"{side} arm reads armDown={arms[side]:.3f} on the deployed page; the avatar is "
+            "standing in a T-pose again (0 is the T-pose, -1 straight down)"
+        )
+
+
 @pytest.mark.deployed
 def test_no_remount(page, space_url, warm_space):
     """AVTR-01, and the direct answer to RESEARCH's Open Question 3.

tests/e2e/test_facade_parity.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import pytest
 
+from tests.e2e.test_stage_standalone import ARM_DOWN_MAX, FIRST_FRAME_TIMEOUT_MS
 from tests.test_transport_seam import avatar_surface
 
 pytestmark = pytest.mark.slow
@@ -21,6 +22,16 @@ TRANSPORTS = ("inline", "iframe")
 AVATAR_READY = "() => !!window.Avatar && !!window.Avatar.__debug && window.Avatar.__debug.ready"
 BOOT_TIMEOUT_MS = 120_000
 
+# 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
+# iframe transport's stage is in another document.
+FIRST_FRAME = """
+async () => {
+  const d = window.Avatar ? await window.Avatar.getDebug() : null;
+  return !!d && d.breathValue !== 0;
+}
+"""
+
 # Deliberately double-quoted and built from data: the surface list must come from
 # facade.js, never from a literal in this file.
 #
@@ -85,6 +96,10 @@ def live_avatars(browser, gradio_apps):
                 "deferred": {name: page.evaluate(CALL_DEFERRED, name) for name in DEFERRED_METHODS},
                 "wired": {name: page.evaluate(PROBE_WIRED, name) for name in WIRED_METHODS},
             }
+            page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
+            captured[transport]["arm_down"] = page.evaluate(
+                "async () => (await window.Avatar.getDebug()).armDown"
+            )
         finally:
             page.close()
     return captured
@@ -116,6 +131,23 @@ def test_transports_expose_identical_debug_keys(live_avatars):
     )
 
 
+def test_arms_rest_at_sides_under_both_transports(live_avatars):
+    """The rest pose is measured on the stage, but a learner sees it through a transport.
+
+    Under the iframe transport the number has to survive a postMessage round trip, which
+    is exactly the kind of field that gets added to the inline path and forgotten on the
+    fallback. Same threshold as the standalone and deployed suites.
+    """
+    for transport in TRANSPORTS:
+        arms = live_avatars[transport]["arm_down"]
+        assert arms is not None, f"{transport}: armDown never reached window.Avatar.getDebug()"
+        for side in ("left", "right"):
+            assert arms[side] < ARM_DOWN_MAX, (
+                f"{transport}: {side} arm reads armDown={arms[side]:.3f}; "
+                "0 is the T-pose, -1 straight down"
+            )
+
+
 def test_deferred_methods_fail_loudly_not_silently(live_avatars):
     """The remaining stubs are placeholders, not accidental no-ops.
 

tests/e2e/test_stage_standalone.py

@@ -17,6 +17,20 @@ pytestmark = pytest.mark.slow
 READY_TIMEOUT_MS = 30_000
 STAGE_READY = "() => !!window.__stageDebug && window.__stageDebug.ready === true"
 
+# armDown is the downward component of the shoulder->elbow direction in world space:
+# -1 straight down, 0 the authored T-pose, +1 straight up. The rest pose puts the upper
+# arm 1.2 rad from horizontal (sin 1.2 = 0.93 down), so -0.7 - an arm within 45 deg of
+# vertical - separates "posed" from "T-pose" by a wide margin while leaving room for the
+# idle sway. Shared verbatim with the deployed suite.
+ARM_DOWN_MAX = -0.7
+
+# `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
+# is only exactly 0 before the first one, which makes it the frame-rendered signal.
+FIRST_FRAME = "() => !!window.__stageDebug && window.__stageDebug.breathValue !== 0"
+FIRST_FRAME_TIMEOUT_MS = 30_000
+
 # Sampling happens INSIDE the page at animation-frame rate rather than by polling from
 # Python. A blink is a 120 ms ramp on a 1.8-5.8 s schedule, so its peak occupies well
 # under 2% of the wall clock: a 250 ms poll would miss it on most runs and the test
@@ -115,6 +129,35 @@ def test_idle_life_values_change(page, static_server):
     )
 
 
+def test_arms_rest_at_sides(page, static_server):
+    """AVTR-01's other half: the avatar stands like a person, not a T-posed statue.
+
+    Every previous assertion in this file passed while the deployed avatar held both arms
+    straight out - a VRM's authored rest pose IS a T-pose and nothing ever moved the arms
+    (docs/evidence/2026-09-05-deployed-tpose.png). The number is read from the RAW bones
+    the mesh is skinned from, after a render, so it measures what the viewer sees.
+    """
+    _open_stage(page, static_server)
+    page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
+    arms = page.evaluate("() => window.__stageDebug.armDown")
+    print(f"[standalone] armDown={arms}")
+
+    assert arms is not None, "armDown is missing from __stageDebug; the stage never measured"
+    for side in ("left", "right"):
+        assert arms[side] < ARM_DOWN_MAX, (
+            f"{side} arm reads armDown={arms[side]:.3f} (0 is the T-pose, -1 straight down); "
+            "the rest pose in vrm-stage.js is not reaching the rendered skeleton"
+        )
+
+    # The idle life must not undo it: two seconds of breathing and sway later, still down.
+    page.wait_for_timeout(2_000)
+    later = page.evaluate("() => window.__stageDebug.armDown")
+    for side in ("left", "right"):
+        assert later[side] < ARM_DOWN_MAX, (
+            f"{side} arm drifted to armDown={later[side]:.3f} after 2 s of idle life"
+        )
+
+
 def test_demo_timeline_drives_visemes(page, static_server):
     """A generated timeline against the real ずんだもん WAV, clocked off the AudioContext.