Posture state machine + device-work animation (laptop spring, typing bursts, gaze/blink)

freestream/avatar.py

@@ -6,12 +6,23 @@ the synthesized audio's per-frame energy. With a user-provided portrait it
 degrades to an audio-reactive waveform badge (rung 2) rather than
 pretending to animate someone's face without a portrait model.
 
+Device-work states (the Animate/ACE/ClawOffice pattern — see
+docs/LATENCY.md "Avatar posture state machine"): the renderer is a posture
+state machine (idle / thinking / working / speaking) plus continuous
+channels (gaze, blink, head tilt). In `working` mode the avatar pulls a
+laptop up from below (spring-eased entrance, mild overshoot), tilts her
+head toward it, and types in Poisson-ish bursts with keystroke pulses and
+screen glow — driven live by agent.tool activity in the bot.
+
 The generated PNG carries tEXt metadata `freestream:procedural=1` so the
 bot knows it can re-render the mouth.
 """
 
 from __future__ import annotations
 
+import random
+import time
+
 import numpy as np
 from PIL import Image, PngImagePlugin
 
@@ -27,14 +38,27 @@ def _face_params(openness: float) -> dict:
     }
 
 
-def render_procedural(openness: float = 0.15, size: int = SIZE) -> Image.Image:
-    """Cartoon assistant face; mouth height follows `openness` (0..1)."""
+def _ease_out_back(t: float) -> float:
+    t = max(0.0, min(1.0, t))
+    c1, c3 = 1.70158, 2.70158
+    return 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2
+
+
+def render_procedural(openness: float = 0.15, size: int = SIZE, mode: str = "idle",
+                      device_t: float = 0.0, typing_pulse: float = 0.0,
+                      blink: float = 0.0, gaze=(0, 0)) -> Image.Image:
+    """Cartoon assistant face; mouth follows `openness`, posture follows
+    `mode`. `device_t` (0..1, eased) slides the laptop in; `typing_pulse`
+    (0..1) bobs the hands and flashes the screen; `blink` closes the eyes."""
     p = _face_params(openness)
     img = Image.new("RGBA", (size, size), (234, 240, 245, 255))
     from PIL import ImageDraw
 
     d = ImageDraw.Draw(img)
-    cx, cy = size // 2, int(size * 0.46)
+    working = device_t > 0.05
+    tilt = int(14 * device_t) if working else 0  # head dips toward the device
+
+    cx, cy = size // 2, int(size * 0.46) + (tilt // 2)
     r = int(size * 0.28)
     # shoulders
     d.ellipse([cx - r * 2, cy + r, cx + r * 2, cy + r * 3], fill=(58, 110, 165, 255))
@@ -42,18 +66,56 @@ def render_procedural(openness: float = 0.15, size: int = SIZE) -> Image.Image:
     d.ellipse([cx - r, cy - r, cx + r, cy + r], fill=(243, 213, 187, 255))
     # hair
     d.ellipse([cx - r, cy - r - 14, cx + r, cy - r + 42], fill=(66, 62, 78, 255))
-    # eyes (blink handled by caller passing openness<0 rarely; keep open)
-    ey = cy - int(r * 0.25)
+    # eyes: gaze channel + blink + device gaze-down
+    gx, gy = gaze
+    if working:
+        gy += int(6 * device_t)
+    ey = cy - int(r * 0.25) + tilt
     for ex in (cx - int(r * 0.42), cx + int(r * 0.42)):
-        d.ellipse([ex - 16, ey - 16, ex + 16, ey + 16], fill=(255, 255, 255, 255))
-        d.ellipse([ex - 7, ey - 7, ex + 7, ey + 7], fill=(40, 40, 48, 255))
-    # brows
-    d.line([cx - int(r * 0.55), ey - 30, cx - int(r * 0.28), ey - 34], fill=(66, 62, 78, 255), width=5)
-    d.line([cx + int(r * 0.28), ey - 34, cx + int(r * 0.55), ey - 30], fill=(66, 62, 78, 255), width=5)
-    # mouth
-    my = cy + int(r * 0.45)
-    d.ellipse([cx - p["mouth_w"], my - p["mouth_h"], cx + p["mouth_w"], my + p["mouth_h"]],
+        ex += gx
+        if blink > 0.5:
+            d.line([ex - 16, ey, ex + 16, ey], fill=(66, 62, 78, 255), width=4)
+        else:
+            d.ellipse([ex - 16, ey - 16, ex + 16, ey + 16], fill=(255, 255, 255, 255))
+            d.ellipse([ex - 7 + gx // 2, ey - 7 + gy, ex + 7 + gx // 2, ey + 7 + gy],
+                      fill=(40, 40, 48, 255))
+    # brows (rise slightly while working — the "checking output" read)
+    brow_dy = -3 if working else 0
+    d.line([cx - int(r * 0.55), ey - 30 + brow_dy, cx - int(r * 0.28), ey - 34 + brow_dy],
+           fill=(66, 62, 78, 255), width=5)
+    d.line([cx + int(r * 0.28), ey - 34 + brow_dy, cx + int(r * 0.55), ey - 30 + brow_dy],
+           fill=(66, 62, 78, 255), width=5)
+    # mouth (concentrating while working: keep it small)
+    mo = openness * (0.25 if working else 1.0)
+    pm = _face_params(mo)
+    my = cy + int(r * 0.45) + tilt
+    d.ellipse([cx - pm["mouth_w"], my - pm["mouth_h"], cx + pm["mouth_w"], my + pm["mouth_h"]],
               fill=(90, 44, 52, 255))
+
+    if working:
+        # laptop slides up from below with easing (device_t 0..1, overshoot ok)
+        dy = int((1.0 - device_t) * 160)
+        lx0, lx1 = 76, SIZE - 76
+        lid_y = SIZE - 150 + dy
+        base_y = SIZE - 60 + dy
+        # base
+        d.rounded_rectangle([lx0, base_y, lx1, base_y + 26], radius=8,
+                            fill=(52, 56, 66, 255))
+        # lid + screen (glow brightens on keystroke pulses)
+        glow = int(150 + 80 * typing_pulse)
+        d.rounded_rectangle([lx0 + 14, lid_y, lx1 - 14, base_y - 4], radius=6,
+                            fill=(36, 40, 50, 255))
+        d.rectangle([lx0 + 30, lid_y + 14, lx1 - 30, base_y - 18],
+                    fill=(90, glow // 2, glow, 255))
+        # scanlines
+        for sy in range(lid_y + 20, base_y - 24, 9):
+            d.line([lx0 + 34, sy, lx1 - 34, sy], fill=(120, 160, 180, 60), width=1)
+        # hands (bob on keystrokes)
+        hand_dy = int(4 * typing_pulse)
+        d.ellipse([cx - 120, base_y - 34 + hand_dy, cx - 70, base_y - 10 + hand_dy],
+                  fill=(243, 213, 187, 255))
+        d.ellipse([cx + 70, base_y - 34 + hand_dy, cx + 120, base_y - 10 + hand_dy],
+                  fill=(243, 213, 187, 255))
     return img
 
 
@@ -90,7 +152,6 @@ def build_mouth_sequence(pcm: np.ndarray, sample_rate: int, fps: int = FPS,
                           .reshape(n, frame_n), axis=1))
     scale = max(rms.max(), 1e-6)
     open_seq = np.clip(rms / scale * 1.4, 0.0, 1.0)
-    # light smoothing so the mouth doesn't jitter
     kernel = np.ones(3) / 3.0
     open_seq = np.convolve(open_seq, kernel, mode="same")
     return np.concatenate([np.zeros(pre_roll_frames), open_seq,
@@ -98,26 +159,107 @@ def build_mouth_sequence(pcm: np.ndarray, sample_rate: int, fps: int = FPS,
 
 
 class AvatarRenderer:
-    """Publish-side frame factory. Procedural face -> re-render mouth;
-    any other portrait -> audio-reactive waveform badge (rung 2)."""
+    """Publish-side frame factory — a posture state machine with continuous
+    channels (gaze, blink, typing cadence), per the ACE/Character-Animator
+    recipe in docs/LATENCY.md:
+
+      idle     gaze camera, breathing, blinks
+      thinking gaze aversion (up/off-screen), small saccades
+      working  laptop springs in, gaze down, Poisson typing bursts,
+               screen glow on each keystroke
+      speaking gaze camera, mouth driven by TTS energy
+    """
 
     def __init__(self, image_path=None):
         self.procedural = image_path is None or is_procedural(image_path)
         self.base = None
         if not self.procedural:
             self.base = Image.open(image_path).convert("RGBA").resize((SIZE, SIZE))
+        # posture state machine
+        self._mode = "idle"
+        self._device_pos = 0.0   # 0 (away) .. 1 (on desk), spring-eased
+        self._device_vel = 0.0
+        self._last_t = time.perf_counter()
+        # continuous channels
+        self._next_blink = time.perf_counter() + random.uniform(2, 5)
+        self._blink_until = 0.0
+        self._saccade_until = 0.0
+        self._saccade = (0, 0)
+        # typing cadence: one-shot keystroke pulses (Cycle-Layers analog)
+        self._keystrokes: list[float] = []
+        self._press_until = 0.0
 
-    def frame(self, openness: float) -> Image.Image:
+    # -- channels -------------------------------------------------------------
+    def _schedule_burst(self, now: float):
+        t = now + random.uniform(0.1, 0.4)
+        for _ in range(random.randint(2, 5)):
+            self._keystrokes.append(t)
+            t += random.uniform(0.08, 0.16)
+
+    def _gaze(self, mode: str, now: float) -> tuple[int, int]:
+        if mode == "working":
+            # down at the device, jittering toward the screen every so often
+            jx = int(np.sin(now * 2.3) * 2)
+            jy = 4 + int(np.sin(now * 1.7) * 1)
+            return (jx, jy)
+        if mode == "thinking":
+            if now > self._saccade_until:
+                self._saccade = (random.randint(-6, 2), random.randint(-6, -3))
+                self._saccade_until = now + random.uniform(0.3, 1.5)
+            return self._saccade
+        return (0, 0)  # speaking / idle: camera
+
+    # -- frame ----------------------------------------------------------------
+    def frame(self, openness: float, mode: str = "idle") -> Image.Image:
         if self.procedural:
-            return render_procedural(openness)
+            now = time.perf_counter()
+            dt = min(0.1, now - self._last_t)
+            self._last_t = now
+
+            if mode != self._mode:
+                self._mode = mode
+
+            # device spring (entrance overshoot for free)
+            target = 1.0 if mode == "working" else 0.0
+            self._device_vel += (target - self._device_pos) * 220 * dt
+            self._device_vel *= 0.80
+            self._device_pos = max(0.0, min(1.15, self._device_pos + self._device_vel * dt))
+            device_t = min(1.0, self._device_pos)
+
+            # blink channel
+            if now >= self._next_blink:
+                self._blink_until = now + 0.14
+                self._next_blink = now + random.uniform(2.0, 6.0)
+            blink = 1.0 if now < self._blink_until else 0.0
+
+            # typing cadence (Poisson-ish bursts)
+            pulse = 0.0
+            if mode == "working":
+                while self._keystrokes and self._keystrokes[0] <= now:
+                    self._keystrokes.pop(0)
+                    self._press_until = now + 0.09
+                if now < self._press_until:
+                    pulse = 1.0
+                if len(self._keystrokes) < 3:
+                    self._schedule_burst(now)
+            else:
+                self._keystrokes.clear()
+
+            return render_procedural(
+                openness, mode=mode, device_t=device_t, typing_pulse=pulse,
+                blink=blink, gaze=self._gaze(mode, now))
+
+        # non-procedural portrait: rung-2 audio-reactive badge (unchanged)
         import copy
 
         img = self.base.copy()
         from PIL import ImageDraw
 
         d = ImageDraw.Draw(img)
-        # audio-reactive waveform badge (rung 2), bottom strip
         bar_h = int(4 + 26 * openness)
+        label = {"working": "working…", "thinking": "thinking…", "speaking": ""}.get(mode, "")
         d.rectangle([40, SIZE - 70, SIZE - 40, SIZE - 40], fill=(20, 22, 28, 200))
         d.rectangle([60, SIZE - 55 - bar_h, 100, SIZE - 55], fill=(80, 200, 120, 255))
+        if label:
+            d.text((120, SIZE - 62), label, fill=(220, 225, 235, 255))
         return img