@voqalize/avatar 0.4.0 → 0.4.2

package/src/avatar.js

@@ -91,8 +91,8 @@ export const STATES = {
   // is kept to a fifth of looks because on a face this real it reads as
   // downcast. The pose takes back `thoughtful`'s lid drop: a thinking face is
   // alert, and the two together measured past the 0.15 that reads drowsy.
-  // The handoff to SPEAKING is in setState: a reply that starts mid-look
-  // finishes the look instead of snapping back.
+  // There is no handoff to SPEAKING any more: a reply that starts mid-look
+  // brings the eyes back with its first word (see enterGaze, 2026-09-21).
   THINKING:           { gaze: 'AWAY_SIDE', emotion: 'thoughtful', engagement: false,
                         // Fixational jumps rare and small: a thinker's eyes rest
                         // where they land. At the default gap the look jittered
@@ -138,11 +138,11 @@ export const STATES = {
                         // eyes drawn inside a head tipped back aimed every look
                         // meant to be level at the ceiling.
                         pose: { lidL: -0.10, lidR: -0.10 } },
-  // Eyes on the user, with the speaker's own looks away (AVERSION.SPEAK):
-  // a planning look at the start of most turns, a short one every ~5 s at a
-  // phrase boundary, and none as the turn ends. A speaker who never looks
-  // away is staring the listener down.
-  SPEAKING:           { gaze: 'USER',     emotion: 'neutral',    aversion: 'SPEAK',
+  // Eyes on the user for the whole turn, and no `aversion`: gaze.js has why a
+  // speaker's measured looks away are not this rig's to render. What moves
+  // while it talks is the head it holds per phrase and the trunk under it
+  // (prosody.js), never the eyes leaving the user.
+  SPEAKING:           { gaze: 'USER',     emotion: 'neutral',
                         idle: { sway: 0.55 }, engagement: false },
   REVIEWING_SCREEN:   { gaze: 'SCREEN_CENTER', emotion: 'thoughtful', engagement: false,
                         idle: { sway: 0.8, blinkGap: [4.0, 6.5] },
@@ -450,7 +450,7 @@ export function createAvatar(opts = {}) {
   // coordinates or the hand layer's private geometry.
   const rig = opts.rig ? opts.rig(mount, opts.rigOptions) : createSvgRig(face, hand);
 
-  gaze.onLargeShift = (forced) => idle.blink(false, true, forced);
+  gaze.onLargeShift = (forced) => idle.blink(true, forced);
 
   const listeners = {
     state: [], speakEnd: [], clipEnd: [], performEnd: [], gestureEnd: [],
@@ -617,7 +617,6 @@ export function createAvatar(opts = {}) {
   let wanderAt = 0;
   let driftAt = 0;
   let trunkYaw = 0;
-  let turnStartPending = false;
   let glanceAt = 0;
   let glanceUntil = 0;
   let lastBack = null;
@@ -627,8 +626,6 @@ export function createAvatar(opts = {}) {
   const dart = { x: 0, y: 0 };
   // THINKING -> SPEAKING mid-look: when the eyes go back to the user, and
   // when that handoff happened (it stands in for the turn-start look).
-  let returnAt = 0;
-  let carriedAt = -Infinity;
   // The state whose gaze is showing, and when the current state takes it
   // over if that is still pending (GAP_SETTLE). Usually the same state.
   let gazeState = 'IDLE';
@@ -754,11 +751,7 @@ export function createAvatar(opts = {}) {
     // spot every time. Either leg's gaze-evoked blink is the shift's odds
     // unless the state says (`blinkTo`, `blinkBack`), because which leg blinks
     // is part of what the glance means.
-    if (returnAt && elapsed > returnAt) {
-      returnAt = 0;
-      setGaze(gst.gaze);
-    }
-    if (gst.glance && !returnAt) {
+    if (gst.glance) {
       const gl = gst.glance;
       if (glanceUntil && elapsed > glanceUntil) {
         glanceUntil = 0;
@@ -807,25 +800,7 @@ export function createAvatar(opts = {}) {
     // mixer's one-frame veto — anything that means "the user is checking
     // whether I am with them" sets it (see api.attend).
     gaze.setAversion(gst.aversion ? AVERSION[gst.aversion] : null);
-    // A speaking turn ends under mutual gaze: no look in the last 2.4 s of the
-    // cue track as far as it has arrived, nor once it has run out (§4.2). The
-    // mid-turn looks wait for a silent cue, which is a phrase boundary. Both
-    // read last frame's sample, a frame late and harmlessly so.
-    let floorReturn = false;
-    gaze.gate = true;
-    if (gst.aversion === 'SPEAK') {
-      const cues = speech.cues;
-      floorReturn = !speech.playing || !cues.length
-        || cues[cues.length - 1].t - speech.now < FLOOR_RETURN_MS;
-      const cue = cues[speech.index];
-      gaze.gate = !!cue && cue.v === SILENT;
-    }
-    gaze.hold = attendUntil > elapsed || clip.playing || floorReturn;
-    if (turnStartPending) {
-      turnStartPending = false;
-      // A reply that began mid-think has had its planning look already.
-      if (elapsed - carriedAt > 1.5) gaze.startTurn();
-    }
+    gaze.hold = attendUntil > elapsed || clip.playing;
 
     engagement.enabled = !!st.engagement && !clip.playing;
     engagement.update(dt);
@@ -1041,11 +1016,6 @@ export function createAvatar(opts = {}) {
   // sliding.
   const TRUNK_FOLLOW = opts.trunkFollow ?? 0.45;
 
-  // Speakers are back on the listener's eyes this long before they stop
-  // (Andrist, docs/research-biomechanics.md §4.2): the floor is handed over
-  // under mutual gaze, and a look away there declines it.
-  const FLOOR_RETURN_MS = 2400;
-
   // The channels speech owns outright — exactly the params.js mouth group
   // (mouth corners stay free: a clip may smile over a sentence).
   const MOUTH_LOCK = new Set(GROUPS.mouth);
@@ -1059,13 +1029,6 @@ export function createAvatar(opts = {}) {
 const ENGAGE_SHOULDER = 0.10;
 const SPEAK_SMILE_RETAIN = 0.35;
 
-  // How long a reply that starts mid-think keeps the look before it comes
-  // back. Speakers look away to find the words and back to deliver them
-  // (§4.2); a reply that snapped to the user on its first syllable and then,
-  // three times in four, left again for the turn-start look did both halves
-  // twice.
-  const THINK_CARRY = [0.25, 0.6];
-
   // Between the user's turn and the reply the server's claim can change
   // several times a second — THINKING, a tool's WORKING, THINKING again, a
   // grace timer's CANT_HEAR — and every change used to retarget the eyes and
@@ -1152,25 +1115,40 @@ const SPEAK_SMILE_RETAIN = 0.35;
     const deferrable = !o.gaze && !o.keepGaze && GAP_STATES.has(gazeState) && GAP_STATES.has(name);
     if (deferrable && changed) settleAt = name === gazeState ? 0 : elapsed + GAP_SETTLE;
     else if (!(deferrable && settleAt)) { settleAt = 0; enterGaze(name, o, changed); }
+    // The floor has come back to the user: the face receives it (prosody.js
+    // `listen`). It is a state change rather than a VAD event on purpose —
+    // what is being welcomed is the turn, and the server is the one that knows
+    // a turn has changed hands.
+    if (changed && name === 'LISTENING') prosody.listen();
     if (changed) emit('state', name);
     return api;
   }
 
+  // Whether the eyes were last aimed by somebody who meant it — the public
+  // `setGaze`, or a performance's `gaze` verb — rather than by the state's own
+  // schedule. It is the one thing that outranks a state's `gaze`, and it is
+  // why `speak()` can take the eyes back without overriding a caller.
+  let gazeExplicit = false;
+
   /** The state `name` takes the gaze: its target and its schedules. */
   function enterGaze(name, o, blink) {
-    const prev = gazeState;
     gazeState = name;
     const st = states[name];
     const gl = st.glance;
-    // A reply that starts while THINKING is looking away finishes that look
-    // first, and the look stands in for the turn-start one.
-    const carry = prev === 'THINKING' && name === 'SPEAKING'
-      && !o.gaze && !o.keepGaze && gazeName !== st.gaze && !glanceUntil;
-    returnAt = carry ? elapsed + rand(THINK_CARRY) : 0;
-    if (carry) carriedAt = elapsed;
+    // **A reply brings the eyes back with its first word, and that is the
+    // whole of it (2026-09-21).** A THINKING look that was still running used
+    // to be carried a quarter to six tenths of a second into the turn, on the
+    // reasoning that a speaker looks away to find the words and back to
+    // deliver them — but what the owner sees at the top of a turn is the
+    // avatar talking while looking somewhere else, and then a dart back. The
+    // carry's own justification was the turn-start aversion it would otherwise
+    // have doubled with, and that aversion is deleted (gaze.js), so nothing is
+    // left for it to avoid. `setGaze` glides; the return is a saccade, not a
+    // cut, and it now lands on the first word instead of after it.
+    //
     // A state with an `opening` enters as though its check-in on the user is
     // already under way, and leaves it when that runs out.
-    if (!o.keepGaze && !carry) setGaze(o.gaze || (gl && gl.opening ? gl.to : st.gaze));
+    if (!o.keepGaze) { setGaze(o.gaze || (gl && gl.opening ? gl.to : st.gaze)); gazeExplicit = false; }
     // Arm every scheduler fresh, so entering a state never fires a timestamp
     // left over from the last one — the wander in particular, which used to
     // pick a new target on the first frame and override the state's own gaze.
@@ -1181,7 +1159,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
     readCol = readCols = readRow = readRows = 0;
     dartAt = dartBrowUntil = 0;
     dart.x = dart.y = 0;
-    if (blink) idle.blink(false, true);
+    if (blink) idle.blink(true);
   }
 
   function setEmotion(name, intensity = 1) { emotion = name; emotionAmt = intensity; return api; }
@@ -1217,8 +1195,18 @@ const SPEAK_SMILE_RETAIN = 0.35;
         : () => performance.now() - speakStart;
     speech.start(o.cues || [], speakClock);
     prosody.reset(newTurn);
-    if (newTurn) turnStartPending = true;
-    if (stateName !== 'SPEAKING') setState('SPEAKING', { keepGaze: true });
+    // **The eyes come back to the user when the audio starts, and that is the
+    // point of inferring the state at all (2026-09-21).** This used to keep
+    // whatever gaze was already set, which meant a reply arriving while
+    // THINKING was looking away spent its *whole turn* aimed off the user —
+    // 11.9 deg off it in `presence.test.ts`, never returning, because nothing
+    // in SPEAKING retargets. The owner's report was of the eyes being
+    // elsewhere as the bot starts talking, and this is the half of it that
+    // survives in a real call: the audit drives the state directly and so
+    // never took this path. `keepGaze` stays for the one caller that means
+    // it — a performance that aimed the eyes with its own `gaze` verb keeps
+    // them, since that is an instruction and not a leftover schedule.
+    if (stateName !== 'SPEAKING') setState('SPEAKING', { keepGaze: gazeExplicit });
     if (o.audio && o.audio.paused) o.audio.play().catch(() => {});
     return api;
   }
@@ -1376,7 +1364,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
       // composed turn in the demo already behaves.
       if (a.do === 'state') setState(a.name, { keepGaze: a.keepGaze !== false });
       else if (a.do === 'emotion') setEmotion(a.name, a.i ?? 1);
-      else if (a.do === 'gaze') setGaze(a.name);
+      else if (a.do === 'gaze') { setGaze(a.name); gazeExplicit = true; }
       else if (a.do === 'action') action(a.id);
     } catch (e) {
       console.warn(`perform: ${a.do} at ${a.t}ms skipped — ${e.message}`);
@@ -1417,7 +1405,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
   }
 
   const api = {
-    setState, setEmotion, setGaze: (name, custom) => setGaze(name, custom), speak, pushCues, stopSpeaking, attend,
+    setState, setEmotion, setGaze: (name, custom) => { gazeExplicit = true; return setGaze(name, custom); }, speak, pushCues, stopSpeaking, attend,
     action, perform,
     /** Which hand the character gestures with: +1 the viewer's right (its own
      *  left), -1 the other. Both are anatomically real — the thumb splays away
@@ -1433,7 +1421,7 @@ const SPEAK_SMILE_RETAIN = 0.35;
     /** Idle body-motion gain: 1 is the liveness layer as authored, 0 freezes it. */
     setMotionGain: (g) => { idle.gain = g; return api; },
     get motionGain() { return idle.gain; },
-    blink: (dbl) => { idle.blink(dbl); return api; },
+    blink: () => { idle.blink(); return api; },
     /** Advance one frame by hand. Only meaningful under `{manual: true}`;
      *  fixed-dt stepping is what makes a motion render reproducible. */
     step: (dt) => { elapsed += dt; step(dt, dt * 1000); return api; },
@@ -1474,12 +1462,29 @@ const SPEAK_SMILE_RETAIN = 0.35;
 // this channel's neutral value" before it can map the channel onto whatever it
 // controls — a morph target's influence is `(pose - rest) / (1 - rest)`, and a
 // rig that hard-codes those rests has quietly forked `params.js`.
-export { REST, CHANNELS, RANGE } from './params.js';
+export { REST, CHANNELS, RANGE, TAU, clamp, approach, makeParams } from './params.js';
+// The smoothing law itself, for a tool that steps the rig by hand. A
+// filmstrip that reimplemented `approach` would be measuring its own copy of
+// the thing under test — and the smoothing between keyframes is what the face
+// actually does (docs/internal-mixer.md § Smoothing).
+// A pose with no mixer above it: `makeParams(overrides)` fills the rests,
+// `avatarFrame` wraps it, `createSvgRig(face).apply` draws it. That is the whole
+// path an instrument needs to hold a face at one named extreme — no clock, no
+// client, no animation — and the reason it is exported is that a pose sheet
+// that cannot reach it forks the channel rests instead.
+export { avatarFrame, createSvgRig } from './rig.js';
 export { ACTION_IDS, ACTIONS, attachAudio } from './interjections.js';
+// The full authoring catalogue and the player that steps it. Not a server
+// vocabulary — `ACTIONS` is that, and most of these clips are reachable only
+// from inside the mixer. They are exported for the filmstrip instrument,
+// which lays one clip out as frames and therefore has to drive a real
+// `ClipPlayer` rather than re-sample its keys.
+export { INTERNAL_CLIPS } from './interjections.js';
+export { ClipPlayer } from './clips.js';
 export { GAZE_NAMES, GAZE_TARGETS } from './gaze.js';
 export { normalizeActions } from './perform.js';
 export { checkHandFraming } from './hand.js';
-export { EMOTION_NAMES } from './emotions.js';
+export { EMOTION_NAMES, emotionPose } from './emotions.js';
 // The mouth clock travels with the rest of it. Someone has to turn a cue array
 // plus a clock into "which letter is on screen right now", every renderer needs
 // exactly that, and none of them should write it twice — so it is a plain class

package/src/faces.js

@@ -2,7 +2,7 @@
  * The faces we ship, as a table — for tooling that wants every one of them.
  *
  * **Importing this costs all three drawings** (~2k lines of path data). That is
- * the right trade for `rig-check`, the contact sheets, the sweep and Studio,
+ * the right trade for the pose sheet, the sweep and Studio,
  * which exist to compare faces against each other. It is the wrong trade for an
  * application, which renders one: those import a single face module and hand
  * the record to `createAvatar` directly.

package/src/gaze.js

@@ -84,9 +84,6 @@ const LID_FOLLOW = { down: 0.34, up: 0 };
 // peaks mid-turn, is gone when the head lands, and sizes itself on a rig whose
 // head moves four times faster. A 0.75-unit look on tara sinks ~0.8°.
 const HEAD_DIP = 0.06;
-// A gated aversion waits this long past its due time for a phrase boundary,
-// then goes anyway: a run of speech with no pause in it still gets its look.
-const GATE_WAIT = 1.5;
 // How much of a drift the head joins. Little: a drift is a reader's scan or a
 // thinker's gaze moving where it rests, and both are eye movements. At 0.35
 // the head nodded along with every step of a reading scan, which on a
@@ -219,30 +216,24 @@ export const AVERSION = {
     mag: [0.30, 0.44],
     dirs: [[-1, 0.06], [-1, 0.06], [1, 0.02], [1, 0.02], [-0.7, -0.5], [0.5, 0.35]],
   },
-  // While speaking: 1.96 s every 4.75 s mid-turn, a turn-start look on 73% of
-  // turns — the planning look, away to find the words and back to deliver
-  // them — and none in the last 2.4 s, because the floor is handed back under
-  // mutual gaze (§4.2; the mixer owns that hold, since only it can see the
-  // cue track). Human speakers hold the listener's eyes for about 41% of a
-  // turn. This is set for 70-80% instead — the
-  // listener here watches a face on a screen, where 41% reads as evasive — so
-  // the looks keep about Andrist's length and come a little less often.
-  // `every` sits under Andrist's 4.75 s because the phrase gate and the
-  // end-of-turn hold both stretch it: at 3.8-5.8 a turn measured 6-8 looks a
-  // minute and 76-82% contact, the top edge of the band rather than its middle.
-  // `gated`: a mid-turn look waits for a phrase boundary, because speakers
-  // break gaze between clauses, not in the middle of a word.
-  SPEAK: {
-    every: [3.4, 5.2],
-    dur: [1.5, 2.3],
-    mag: [0.34, 0.48],
-    dirs: [[-1, 0.12], [1, 0.12], [-0.75, 0.55], [0.7, 0.5], [-0.6, -0.45]],
-    gated: true,
-    start: { p: 0.73, dur: [1.1, 1.8], window: 0.8 },
-  },
 };
-// There is deliberately no THINK profile. The *cognitive* aversion — 3.54 s
-// (SD 1.26), splitting 39.3% down / 29.4% up / 31.3% side (§4.2) — is longer
+// **There is deliberately no SPEAK profile, and that is the owner's call
+// (2026-09-21): while the avatar talks, its eyes are on the user.** There was
+// one — Andrist's measured speaker, a planning look away at the start of most
+// turns and a short one every few seconds at a phrase boundary — and in a live
+// call it read as the eyes darting off and coming back. The research it came
+// from is not disputed and the reason it does not transfer is structural: a
+// human speaker's look away is a *head and body* movement that the eyes only
+// lead, and this rig has no such movement to give it. Eye travel on its own is
+// not a smaller version of that, it is a different thing, and on tara the
+// amplitude it needed to be visible at all (`aversionGain` 1.8) is exactly what
+// made it read as a dart. What the speaking face moves instead is the head it
+// holds per phrase and the trunk under it (prosody.js), which is communicative
+// rather than evasive. If the face and body half is ever built, this is where
+// the eye half comes back.
+//
+// There is deliberately no THINK profile either. The *cognitive* aversion —
+// 3.54 s (SD 1.26), splitting 39.3% down / 29.4% up / 31.3% side (§4.2) — is longer
 // and deeper than the listening kind, and THINKING renders it with its own
 // dwell cycle (a `glance` in STATES), which moves the whole gaze target rather
 // than nudging off it. Two mechanisms producing the same look would fight.
@@ -296,9 +287,6 @@ export class GazeLayer {
     this._avHead = { x: 0, y: 0 };
     this._avVel = { x: 0, y: 0 };
     this._avProfileRef = undefined;
-    /** Whether now is a phrase boundary, for a `gated` profile. Set by the mixer. */
-    this.gate = true;
-    this._avStartBy = 0;       // a turn-start look may still fire until this time
     // --- drift: a small held offset about the target, set by the mixer
     this.drift = { x: 0, y: 0 };
     this._drift = { x: 0, y: 0 };
@@ -313,15 +301,6 @@ export class GazeLayer {
     // it is entered off a stale timestamp from one that didn't.
     this._avNext = this._t + (p ? p.every[0] + Math.random() * (p.every[1] - p.every[0]) : 0);
     this._avUntil = 0;
-    this._avStartBy = 0;
-  }
-
-  /** A turn begins. If the profile has a turn-start look and the dice take it,
-   *  it fires as soon as `hold` allows inside its window, or not at all — a
-   *  planning look that arrives a second into the words is just a look. */
-  startTurn() {
-    const s = this.aversion && this.aversion.start;
-    if (s && Math.random() < s.p) this._avStartBy = this._t + s.window;
   }
 
   _avert(t, dt) {
@@ -339,17 +318,13 @@ export class GazeLayer {
       // moment the hold lifted — out, back and out again across one turn
       // edge, which is three saccades where the floor wanted none.
       this._avUntil = 0;
-      this._avStartBy = 0;
       this._avNext = t + p.every[0] + Math.random() * (p.every[1] - p.every[0]);
     } else if (this._avUntil && t >= this._avUntil) {
       this._avUntil = 0;
       this._nextMicro = 0;
       this._avNext = t + p.every[0] + Math.random() * (p.every[1] - p.every[0]);
-    } else if (!this._avUntil && !this.hold && (t < this._avStartBy || (t >= this._avNext
-        && (this.gate || !p.gated || t >= this._avNext + GATE_WAIT)))) {
-      const dur = t < this._avStartBy ? p.start.dur : p.dur;
-      this._avStartBy = 0;
-      this._avUntil = t + dur[0] + Math.random() * (dur[1] - dur[0]);
+    } else if (!this._avUntil && !this.hold && t >= this._avNext) {
+      this._avUntil = t + p.dur[0] + Math.random() * (p.dur[1] - p.dur[0]);
       this._nextMicro = 0;
       const d = p.dirs[(Math.random() * p.dirs.length) | 0];
       const m = (p.mag[0] + Math.random() * (p.mag[1] - p.mag[0])) * this.avertGain;

package/src/idle.js

@@ -54,7 +54,13 @@ import { HeadPose } from './head.js';
  */
 export const DEFAULT_PROFILE = {
   sway: 1.0,
-  settle: [1.8, 4.6],
+  // A head re-positions oftener than it used to (2026-09-21). On a character
+  // whose held angle is budgeted this is the half of "more movement" that
+  // actually arrives: the angle is capped by `headHold` and the *rate* is not,
+  // so a body that re-settles every couple of seconds reads as more alive than
+  // one that reaches further every five. Still an event every second or two at
+  // its fastest, which is nowhere near the 1.5 Hz line.
+  settle: [1.4, 3.4],
   blinkGap: [1.9, 5.4],
   slowBlink: 0,
   breathRate: 1.0,
@@ -62,7 +68,7 @@ export const DEFAULT_PROFILE = {
   hold: null,
   rhythm: null,
   flick: null,
-  shift: [9, 22],
+  shift: [7, 16],
 };
 
 const rand = ([a, b]) => a + Math.random() * (b - a);
@@ -120,7 +126,7 @@ function nextPosture(prev) {
   // a mechanism that is invisible half the time reads as a body that only
   // moves sometimes. Nobody shifts their weight by a millimetre. The 25% that
   // stays on the same side is what keeps it off a left-right metronome.
-  const mag = 0.16 + Math.random() * 0.26;
+  const mag = 0.20 + Math.random() * 0.32;
   const away = prev.torsoTurn > 0 ? -1 : prev.torsoTurn < 0 ? 1 : (Math.random() < 0.5 ? -1 : 1);
   const turn = mag * (Math.random() < 0.75 ? away : -away);
   const leanAway = prev.torsoLean > 0 ? -1 : 1;
@@ -158,11 +164,24 @@ function nextPosture(prev) {
  * and not a small number, is what keeps pitch off the wire's vocabulary. It was
  * held to under a degree as well, which measured as a listening head with no
  * pitch in it at all (1.05° peak over thirty seconds, against yaw's 5.5°), and
- * a head that only ever turns is a head on a turntable. The range is wider now
- * and still biased upward: a chin that drifts down and stays there is the
- * downcast read, which on a photographed face arrives long before any other.
+ * a head that only ever turns is a head on a turntable. The range is biased
+ * upward: a chin that drifts down and stays there is the downcast read, which
+ * on a photographed face arrives long before any other.
+ *
+ * **Widened again on 2026-09-21, on the owner's read that the whole figure is
+ * too restricted.** The ceiling here is not this table — it is `headHold` in
+ * the mixer (step 6b), which softens what the layers together ask the head to
+ * *hold* against the angle the owner measured on each character by eye
+ * (`motion-limits.json`). So these numbers are what the drawing gets and what a
+ * budgeted character gets is its own measured angle, which is the arrangement
+ * this file should have been sized against all along: on tara the widest settle
+ * yaw is 4.9° under a 6° hold budget, the widest pitch 2.6° under 5°, and roll
+ * stays the most conservative of the three because her roll *transition* is a
+ * recorded defect at any angle. The `dur` is untouched — a wider move over the
+ * same half second is a faster move, not a busier one, and the frequency is
+ * what the movement budget is about (CLAUDE.md).
  */
-const SETTLE = { yaw: [0.16, 0.34], pitch: [-0.11, 0.08], roll: [0.10, 0.28], dur: [0.45, 0.8], switchP: 0.7 };
+const SETTLE = { yaw: [0.22, 0.46], pitch: [-0.15, 0.11], roll: [0.14, 0.38], dur: [0.45, 0.8], switchP: 0.7 };
 const HOME = { headYaw: 0, headPitch: 0, headRoll: 0 };
 
 /**
@@ -186,7 +205,7 @@ const HOME = { headYaw: 0, headPitch: 0, headRoll: 0 };
  * same gate, so a quiet head does not sit on a torso still rocking under it.
  */
 const LIVE = {
-  yaw: 0.05, pitch: 0.02, roll: 0.05, breathPitch: 0.006,
+  yaw: 0.07, pitch: 0.028, roll: 0.07, breathPitch: 0.006,
   retarget: [0.6, 2.2], tau: 0.38,
   drift: [2.0, 5.0], still: [1.2, 3.5], stillGain: 0.12,
 };
@@ -208,7 +227,6 @@ export class IdleLayer {
     this._nextBlink = 2 + Math.random() * 3;
     this._blinkT = -1;
     this._blinkDur = 0.13;
-    this._double = false;
     this._lastBlinkAt = -Infinity;
     // Two incommensurate frequencies per axis so the sway never visibly loops.
     this._ph = [Math.random() * 9, Math.random() * 9, Math.random() * 9];
@@ -294,19 +312,18 @@ export class IdleLayer {
    * rate is a decision to revisit in that state, not something for the eyelids
    * to drop silently.
    */
-  blink(double = false, evoked = false, forced = false) {
+  blink(evoked = false, forced = false) {
     if (evoked) {
       if (this.t - this._lastBlinkAt < BLINK_REFRACTORY) return;
       const gap = this._nextBlink - this._lastBlinkAt;
       if (!forced && this.t - this._lastBlinkAt < EVOKED_EARLIEST * gap) return;
     }
-    this._startBlink(0.11 + Math.random() * 0.04, double);
+    this._startBlink(0.11 + Math.random() * 0.04);
   }
 
-  _startBlink(dur, double) {
+  _startBlink(dur) {
     if (this._blinkT >= 0) return;
     this._blinkT = 0;
-    this._double = double;
     this._blinkDur = dur;
     this._lastBlinkAt = this.t;
     this._nextBlink = this.t + rand(this.profile.blinkGap);
@@ -319,12 +336,12 @@ export class IdleLayer {
    * of speech with no pauses in it.
    */
   phraseBlink() {
-    this.blink(false, true);
+    this.blink(true);
   }
 
   /** A slow, deliberate blink — reads as thinking or fatigue. */
   slowBlink() {
-    this._startBlink(0.34, false);
+    this._startBlink(0.34);
   }
 
   _blinkValue(dt) {
@@ -333,7 +350,6 @@ export class IdleLayer {
     const d = this._blinkDur;
     const p = this._blinkT / d;
     if (p >= 1) {
-      if (this._double) { this._double = false; this._blinkT = 0; return 0; }
       this._blinkT = -1;
       return 0;
     }
@@ -351,10 +367,15 @@ export class IdleLayer {
       // Re-armed here as well as in _startBlink, for the frame the timer comes
       // due in the middle of a blink already running.
       this._nextBlink = t + rand(pr.blinkGap);
-      // A share of them slow if the state asks for it; roughly one in six of
-      // the rest comes in a pair.
+      // A share of them slow if the state asks for it. **The rest are single,
+      // and a paired blink is not a thing this layer does** — a share of them
+      // used to re-close the instant the lid reached open, which at this
+      // duration is a 7-9 Hz flutter and was read by the owner on 2026-09-21 as
+      // a dropped frame rather than as a pair. A human doublet is two blinks a
+      // few hundred ms apart, which is what the gap already produces when it
+      // draws short; nothing in research-biomechanics.md asks for the rest.
       if (Math.random() < pr.slowBlink) this.slowBlink();
-      else this.blink(Math.random() < 0.16);
+      else this.blink();
     }
     const blink = this._blinkValue(dt);
 
@@ -524,6 +545,12 @@ export class IdleLayer {
         // actually present on screen. `gain` is where a deployment that
         // really is paying for the pixels turns it back down.
         // The head is the exception: it settles rather than sways (SETTLE).
+        // The *idle* terms below went up again on 2026-09-21 — the owner read
+        // the figure as too restricted — and only the idle terms: the speech
+        // share is `prosody.js`'s business and is raised there, beside the
+        // words it is timed to. These are all far below 1.5 Hz, so the raise
+        // buys excursion and not rate; what it costs the encoder is a slightly
+        // larger slow motion, which is the cheap kind.
         headYaw: hs.headYaw + flickYaw + post.headYaw * ps,
         headPitch: hs.headPitch + workPitch,
         headRoll: hs.headRoll + post.headRoll * ps,
@@ -531,9 +558,16 @@ export class IdleLayer {
         // outbreath over the phrase (research-biomechanics.md §6.1), which the
         // prosody layer draws. Quiet breathing steps mostly back under it.
         breath: breath * this.gain * (1 - 0.6 * this.talk),
-        // The brows are never quite still either.
-        browRaiseL: s(0, 0.089) * 0.020 * a,
-        browRaiseR: s(1, 0.083) * 0.020 * a,
+        // The brows are never quite still either — and they were nearly still
+        // here, at an amplitude a beat could swallow whole. Two video
+        // reviewers named a motionless upper face as the biggest reason these
+        // read as uncanny; `prosody.POSE.brow` answered that for a face that
+        // is *talking*, and the avatar listens far more than it speaks
+        // (CLAUDE.md). The two rates are further apart than they were so the
+        // pair drifts out of phase inside one call rather than over several:
+        // a matched pair is the drawing, not the face.
+        browRaiseL: s(0, 0.089) * 0.032 * a,
+        browRaiseR: s(1, 0.071) * 0.032 * a,
         // Shoulders, and the body's share of speech emphasis — a head that
         // moves on its own above a torso that never does is the head-on-a-stick
         // read, and it was the loudest note in the first round of stakeholder
@@ -559,15 +593,15 @@ export class IdleLayer {
         // said should be the louder. What is left here is the part prosody
         // cannot supply: motion in the gaps *between* phrases, where there is
         // no accent to hang anything on.
-        shoulderL: (s(1, 0.11) * 0.5 + s(2, 0.22) * 0.5) * (0.040 * ad + 0.045 * say * this.gain)
+        shoulderL: (s(1, 0.11) * 0.5 + s(2, 0.22) * 0.5) * (0.052 * ad + 0.045 * say * this.gain)
           + workL + post.shoulderL * ps,
-        shoulderR: (s(2, 0.10) * 0.5 + s(0, 0.19) * 0.5) * (0.040 * ad + 0.045 * say * this.gain)
+        shoulderR: (s(2, 0.10) * 0.5 + s(0, 0.19) * 0.5) * (0.052 * ad + 0.045 * say * this.gain)
           + workR + post.shoulderR * ps,
-        torsoLean: s(0, 0.085) * (0.028 * ad + 0.035 * say * this.gain) + post.torsoLean * ps,
+        torsoLean: s(0, 0.085) * (0.036 * ad + 0.035 * say * this.gain) + post.torsoLean * ps,
         // The trunk's own drift, small next to the weight shift that dominates
         // this channel. It exists so the body is not perfectly still *between*
         // shifts, which would make each shift read as a discrete event.
-        torsoTurn: (s(2, 0.047) * 0.6 + s(1, 0.031) * 0.4) * 0.06 * a
+        torsoTurn: (s(2, 0.047) * 0.6 + s(1, 0.031) * 0.4) * 0.075 * a
           + post.torsoTurn * ps,
       },
     };