@topy-ai/maggie 0.7.61 → 0.8.1

package/bundled-tools/runtime/spirit_agent.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""Animate the Core-Agent faces through the 32-state system.
+
+The agent's face (hair / eyes / prop) is the fixed identity; its ONEMAN O-rim
+is the animatable ring — it reuses the exact motion vocabulary + palette +
+badges from sprite_system.CATALOG (thinking sweeps, loading fills, critical
+blinks, success turns green, awaiting shows the clock badge, …). `speaking`
+also opens the mouth. Emits a PNG frame strip + still per state, a sprite sheet
+and states.json per agent, into brand/<role>/.
+"""
+import sys, os, json, math
+HERE=os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0,HERE)
+OUT_BASE=HERE
+import spirit_face as F
+from spirit_base import CATALOG, GLYPH, palette, GROUPS
+from PIL import Image
+
+W,H,cx,cy=F.W,F.H,F.cx,F.cy
+R_IN,R_OUT=F.R_IN,F.R_OUT
+shade=F.shade; OUT=F.OUT
+
+# rim cells (annulus) ordered by angle from top, clockwise
+RIM=[]
+for y in range(H):
+    for x in range(W):
+        d=math.hypot(x-cx,y-cy)
+        if R_IN-0.5<=d<=R_OUT: RIM.append((x,y))
+def _ang(p): return (math.atan2(p[1]-cy,p[0]-cx)+math.pi/2)%(2*math.pi)
+RIM.sort(key=_ang)
+ANG={p:_ang(p) for p in RIM}
+
+BX,BY=22,0
+def put_badge(px,name,bg,fg):
+    for yy in range(0,6):
+        for xx in range(21,27): px[(xx,yy)]=None
+    g=GLYPH[name]
+    for r in range(5):
+        for c in range(5): px[(BX+c,BY+r)]=fg if g[r][c]=="1" else bg
+def tri(t,nf): x=(2*t/nf); return x if x<=1 else 2-x
+
+WHT=F.WHT; EYE=F.EYE
+EYEPROPS={"glasses","shades","monocle"}     # cover the eyes -> don't redraw eyes under them
+MOUTHPROPS={"cigar"}                         # at the mouth -> keep base mouth
+
+# ---- expression layer: per-state face animation (generic, reusable) ----
+# state -> (eye-mode, mouth-mode). Blink is added automatically on longer loops.
+EXPR={
+ "off":("closed","flat"),"booting":("wake","small"),"idle":("open","smile_s"),
+ "active":("open","smile_s"),"paused":("half","flat"),"offline":("closed","flat"),
+ "thinking":("up","small"),"loading":("open","flat"),"syncing":("dart","flat"),
+ "writing":("down","small"),"streaming":("open","talk"),"queued":("open","flat"),
+ "scanning":("dart","flat"),"deploying":("determined","flat"),
+ "speaking":("open","talk"),"listening":("side","small"),
+ "notification":("wide","small"),"mention":("side","smile"),"recording":("open","flat"),
+ "success":("happy","grin"),"warning":("worried","frown"),"critical":("wide","frown"),
+ "blocked":("side","flat"),"error":("x","frown"),"retrying":("determined","flat"),
+ "awaiting":("up","small"),"approved":("happy","smile"),"rejected":("worried","frown"),
+ "secure":("open","smile_s"),"vulnerable":("worried","frown"),"maintenance":("down","flat"),
+ "celebrating":("happy","grin"),
+}
+def _clear(px,x0,y0,x1,y1,SK):
+    for y in range(y0,y1+1):
+        for x in range(x0,x1+1): px[(x,y)]=SK
+def draw_eyes_expr(px,mode,t,nf,SK,lash,blink):
+    for s in(-1,1):
+        _clear(px,cx+s*3 if s>0 else cx-6, cy-3, cx+6 if s>0 else cx-3, cy, SK)
+    if blink: mode="closed"
+    def whites(s):
+        for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-2)]=WHT; px[(x,cy-1)]=WHT
+    def lashmark(s):
+        if lash: px[(cx+s*6,cy-2)]=OUT; px[(cx+s*5,cy-3)]=OUT
+    for s in(-1,1):
+        if mode=="closed":
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=OUT
+            lashmark(s); continue
+        if mode=="half":
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=WHT
+            px[(cx+s*4,cy-1)]=EYE
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-2)]=OUT
+            continue
+        if mode=="happy":
+            px[(cx+s*5,cy-1)]=OUT; px[(cx+s*4,cy-2)]=OUT; px[(cx+s*3,cy-1)]=OUT; continue
+        if mode=="x":
+            px[(cx+s*3,cy-2)]=OUT; px[(cx+s*4,cy-1)]=OUT; px[(cx+s*5,cy)]=OUT
+            px[(cx+s*5,cy-2)]=OUT; px[(cx+s*3,cy)]=OUT; continue
+        whites(s); lashmark(s)
+        pdx, pdy = 0, 0
+        if mode=="up": pdy=-1
+        elif mode=="down": pdy=0; px[(cx+s*3,cy-2)]=EYE  # lowered lid feel
+        elif mode=="side": pdx=1
+        elif mode=="dart": pdx=1 if (t%2==0) else -1
+        elif mode=="wide": pass
+        elif mode=="worried": px[(cx+s*4 if s<0 else cx+s*3,cy-3)]=OUT  # inner brow down
+        elif mode=="determined": px[(cx+s*5,cy-3)]=OUT                   # outer brow
+        px[(cx+s*(4+pdx), cy-1+pdy)]=EYE
+        if mode not in("wide","up"): px[(cx+s*4, cy-2)]=EYE if pdy==0 else WHT
+        if mode=="wake" and t< nf//2:
+            for x in(cx+s*3,cx+s*4,cx+s*5): px[(x,cy-1)]=OUT; px[(x,cy-2)]=SK
+def draw_mouth_expr(px,mode,t,SK,mcol):
+    _clear(px,cx-2,cy+3,cx+2,cy+5,SK)
+    if mode=="smile" or mode=="smile_s":
+        px[(cx-2,cy+4)]=OUT;px[(cx-1,cy+5)]=OUT;px[(cx,cy+5)]=OUT;px[(cx+1,cy+5)]=OUT;px[(cx+2,cy+4)]=OUT
+    elif mode=="grin":
+        px[(cx-2,cy+4)]=OUT;px[(cx+2,cy+4)]=OUT
+        for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT; px[(x,cy+5)]=WHT
+    elif mode=="flat":
+        for x in range(cx-2,cx+2): px[(x,cy+4)]=OUT
+    elif mode=="frown":
+        px[(cx-2,cy+5)]=OUT;px[(cx-1,cy+4)]=OUT;px[(cx,cy+4)]=OUT;px[(cx+1,cy+4)]=OUT;px[(cx+2,cy+5)]=OUT
+    elif mode=="small":
+        px[(cx,cy+4)]=OUT; px[(cx-1,cy+4)]=OUT
+    elif mode=="talk":
+        if t%2:
+            for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT;px[(x,cy+5)]=OUT
+            px[(cx,cy+5)]=F._rgb('7a1a12')
+        else:
+            for x in range(cx-1,cx+2): px[(x,cy+4)]=OUT
+    if mcol and mode in("smile","smile_s","flat","grin"):     # lipstick tint
+        for x in range(cx-2,cx+3):
+            if px.get((x,cy+4))==OUT: px[(x,cy+4)]=mcol
+
+# ---- per-agent signature micro-animation on the prop (always-on identity) ----
+def prop_anim(px,prop,t,nf,propcol):
+    ph=t%max(1,nf); frac=t/max(1,nf); rgb=F._rgb
+    if prop=="cigar":
+        for k in range(2):                                  # smoke curl rising
+            yy=(cy+2)-((ph+k*2)%6); xx=cx+9+((ph+k)%2)
+            if yy>=cy-4: px[(xx,yy)]=rgb('9a9aa8') if k==0 else rgb('6a6a7a')
+        px[(cx+8,cy+4)]=rgb('ff4422') if ph%2==0 else rgb('ff7a44')   # ember flicker
+    elif prop=="headset":
+        px[(cx-6,cy+4)]=rgb('ff4422') if ph%2==0 else rgb('5a1a10')   # mic light blink
+    elif prop in("shades","glasses"):
+        gx=cx-5+int(frac*11)                                # glint sweeps both lenses
+        for lx0,lx1 in((cx-5,cx-1),(cx+2,cx+6)):
+            if lx0<=gx<=lx1: px[(gx,cy-1)]=WHT
+    elif prop=="monocle":
+        gx=cx+2+int(frac*4)
+        if cx+2<=gx<=cx+6: px[(gx,cy-1)]=WHT
+        px[(cx+4+(1 if ph%2 else 0),cy+2)]=rgb('d4af37')     # chain sway
+    elif prop=="pen":
+        if ph%2==0: px[(cx+8,cy-1)]=rgb('f2c75a')            # write spark at the nib
+    elif prop=="earbuds":
+        w=rgb('9fe8ff')
+        if ph%2==0: px[(cx-10,cy)]=w; px[(cx+10,cy)]=w        # sound waves pulse out
+        else: px[(cx-11,cy-1)]=w; px[(cx+11,cy-1)]=w
+    elif prop=="bandana":
+        dy=1 if ph%2 else 0; BC=rgb(propcol or 'ef4444')
+        px[(cx-11,cy+dy)]=BC; px[(cx-11,cy+1+dy)]=shade(BC,-22)  # tail flutter
+
+def founder_anim(px,t,nf):
+    rgb=F._rgb; ph=t%max(1,nf); frac=t/max(1,nf)
+    gx=cx-5+int(frac*11)                                 # glasses glint sweep
+    for lx0,lx1 in((cx-5,cx-3),(cx+3,cx+5)):
+        if lx0<=gx<=lx1: px[(gx,cy-1)]=WHT
+    GL = rgb('39d353') if ph%2==0 else rgb('1f7a3a')     # green mask-vent pulse
+    for k in range(3): px[(cx+3,cy+4+k)]=GL
+    BC=rgb('e23b3b'); BCd=shade(BC,-24); w=1 if ph%2 else 0   # right-side tails ripple in the wind
+    for strand in(0,1):
+        for k in range(2,6):
+            xx=cx+8+k; yy=(cy-2-strand*2)-(k*2)//3-(w if k>=3 else 0)
+            if 0<=xx<W and 0<=yy<H: px[(xx,yy)]=BC if k<3 else BCd
+
+NF={"breathe":10,"breathe_slow":10,"pulse":8,"blink":2,"arc":12,"scan":12,"spin":10,
+    "dualarc":12,"fill":12,"boot":10,"dots":6,"sparkout":4,"sparkin":4,"celebrate":8}
+
+def frames(base, rim_live, state, P, ctx):
+    grp,role,motion,badge,fps=CATALOG[state]
+    col=P[role] if role in P else P["accent"]
+    nf=NF[motion]; out=[]
+    SK=F.SKINS[ctx["skin"]]; lash=(ctx["gender"]=="f")
+    eyemode,mouthmode=EXPR[state]
+    for t in range(nf):
+        px=dict(base)
+        def setrim(fn):
+            for i,p in enumerate(rim_live): px[p]=fn(i,p)
+        n=len(rim_live)
+        if motion in("breathe","breathe_slow"):
+            cc=shade(col,(10 if motion=="breathe_slow" else 16)*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="pulse":
+            cc=shade(col,42*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="blink":
+            cc=col if t%2==0 else shade(col,-60); setrim(lambda i,p:cc)
+        elif motion in("arc","scan","spin"):
+            win={"arc":80,"scan":34,"spin":54}[motion]; a0=(t/nf)*2*math.pi; w=math.radians(win)
+            setrim(lambda i,p:(P["acc_hot"] if min((ANG[p]-a0)%(2*math.pi),(a0-ANG[p])%(2*math.pi))<=w/2 else P["acc_dim"]))
+        elif motion in("fill","boot"):
+            prog=(t+1)/nf; setrim(lambda i,p:(col if (i/max(1,n))<=prog else P["acc_dim"]))
+        elif motion=="dualarc":
+            a0=(t/nf)*2*math.pi; w=math.radians(70)
+            def cm(i,p):
+                for b in(a0,a0+math.pi):
+                    if min((ANG[p]-b)%(2*math.pi),(b-ANG[p])%(2*math.pi))<=w/2: return P["acc_hot"]
+                return P["acc_dim"]
+            setrim(cm)
+        elif motion=="dots":
+            cc=shade(col,14*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="sparkin":
+            cc=shade(col,16*tri(t,nf)); setrim(lambda i,p:cc)
+        elif motion=="celebrate":
+            cyc=[P["green"],P["amber"],P["accent"],P["acc_spark"]]; cc=cyc[t%len(cyc)]; setrim(lambda i,p:cc)
+        else:  # sparkout + fallbacks: steady rim
+            setrim(lambda i,p:col)
+        # ---- personalized expression (eyes + mouth per state) ----
+        blink = (nf>=6 and t==nf-1)                      # a blink each loop on longer states
+        eyeCov=(ctx["prop"] in EYEPROPS) or ctx.get("specs")
+        mouthCov=(ctx["prop"] in MOUTHPROPS) or ctx.get("mask")
+        if not eyeCov:
+            draw_eyes_expr(px,eyemode,t,nf,SK,lash,blink)
+        if not mouthCov:
+            mcol=F._rgb('c0392b') if ctx.get("mouth")=="lips" else None
+            draw_mouth_expr(px,mouthmode,t,SK,mcol)
+        if ctx.get("founder"): founder_anim(px,t,nf)             # founder signature anim
+        else: prop_anim(px, ctx["prop"], t, nf, ctx.get("propcol"))
+        if badge:
+            nm,bg,fg=badge; put_badge(px,nm,P[bg],P[fg])
+        out.append(px)
+    return out, fps
+
+def gen_agent(role, accent, gender, params, scale=8):
+    P=palette(accent)
+    base=F.face(accent, gender=gender, **params)
+    rim_live=[p for p in RIM if base.get(p) in (F._rgb(accent), shade(F._rgb(accent),-30))]
+    ctx={"skin":params.get("skin","mid"),"gender":gender,"prop":params.get("prop"),
+         "mouth":params.get("mouth"),"propcol":params.get("propcol"),
+         "specs":params.get("specs"),"mask":params.get("mask"),"founder":(role=="founder")}
+    out=os.path.join(OUT_BASE, role); os.makedirs(out, exist_ok=True)
+    # wipe old O+1 agent files
+    for fn in os.listdir(out):
+        if fn.endswith(('.png','.svg','.json')): os.remove(os.path.join(out,fn))
+    meta={"title":role.upper(),"accent":accent,"gender":gender,"W":W,"H":H,"scale":scale,"groups":GROUPS,"states":{}}
+    def render(px): return F.render(px,scale)
+    for s in CATALOG:
+        frs,fps=frames(base,rim_live,s,P,ctx)
+        imgs=[render(px) for px in frs]
+        w=sum(i.width for i in imgs); strip=Image.new("RGBA",(w,imgs[0].height),(0,0,0,0)); x=0
+        for i in imgs: strip.paste(i,(x,0)); x+=i.width
+        strip.save(os.path.join(out,f"anim-{s}.png"))
+        render(frs[0]).save(os.path.join(out,f"still-{s}.png"))
+        grp,role_,motion,badge,_=CATALOG[s]
+        meta["states"][s]={"group":grp,"frames":len(frs),"fps":fps,"motion":motion,"badge":badge[0] if badge else None}
+    # sprite sheet (8x4, representative frame)
+    def rep(m,n): return {"blink":0,"fill":int(n*.62),"boot":int(n*.62),"arc":n//4,"scan":n//4,"spin":n//4,"dualarc":n//4,"dots":1}.get(m,n//2)
+    cols,rows,cell=8,4,6
+    tw=W*cell*0+W; # overview uses small renders
+    cellimg=lambda px: F.render(px, 5)
+    order=[s for g in GROUPS for s in CATALOG if CATALOG[s][0]==g]
+    tile=W*5; pad=6
+    sheet=Image.new("RGBA",(cols*tile+(cols+1)*pad, rows*(H*5)+(rows+1)*pad),(16,16,24,255))
+    for i,s in enumerate(order):
+        frs,_=frames(base,rim_live,s,P,ctx); im=cellimg(frs[rep(CATALOG[s][2],len(frs))])
+        X=pad+(i%cols)*(tile+pad); Y=pad+(i//cols)*(H*5+pad); sheet.paste(im,(X,Y),im)
+    sheet.save(os.path.join(out,"sprite-sheet.png"))
+    json.dump(meta, open(os.path.join(out,"states.json"),"w"), indent=1)
+    return meta
+
+if __name__=="__main__":
+    only=sys.argv[1] if len(sys.argv)>1 else None
+    for role,acc,g,p in list(F.CAST)+[F.FOUNDER]:
+        r=role.lower()
+        if only and r!=only: continue
+        m=gen_agent(r,acc,g,p)
+        print(f"{role} {acc} {g}: {len(m['states'])} states -> brand/{r}/")

package/bundled-tools/runtime/spirit_base.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""ONEMAN sprite system — the reusable animated status-sprite basic set.
+
+Every ONEMAN agent (Core or Service) shares ONE visual language: a 17x17 flat
+pixel motif, a fixed semantic palette tinted by the agent's accent, a catalog of
+32 common states, and a vocabulary of animation primitives. Give this generator
+a Motif (the agent's mark) + an accent colour and it emits the whole set in a
+consistent style: an animated PNG frame strip per state, a still SVG per state,
+a combined overview sheet, and states.json (frames + fps) to drive CSS/canvas.
+
+The ONEMAN mark (a blocky O ring + central 1 bar, accent #ff1212 = topy.ai) is
+the default motif. A new agent reuses everything here and supplies only its own
+motif grid + accent, so the whole roster animates and reads identically.
+
+Usage:
+    python3 sprite_system.py                      # regenerate the ONEMAN set
+    from sprite_system import Motif, generate      # build another agent's set
+    generate(Motif.oneman(), accent="#ff1212", out="oneman", title="ONEMAN")
+
+PIL only (no cairosvg).
+"""
+from __future__ import annotations
+import json, math, os
+from PIL import Image, ImageDraw
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+OUT_BASE = HERE
+
+# ---------------------------------------------------------------- palette ----
+def _rgb(h): h=h.lstrip("#"); return (int(h[0:2],16),int(h[2:4],16),int(h[4:6],16))
+def shade(c, amt):
+    """Lighten (amt>0) or darken (amt<0) an rgb tuple toward white/black, in %."""
+    f=lambda v: max(0,min(255,round(v+(amt/100)*((255-v) if amt>0 else v))))
+    return (f(c[0]),f(c[1]),f(c[2]))
+
+# fixed semantic colours shared by every agent (danger/success/etc are universal)
+SEM = {"red":_rgb("ff1212"), "green":_rgb("36c76a"), "amber":_rgb("f2b01e"),
+       "blue":_rgb("3a9bff"), "grey":_rgb("4a4a58"), "ink":_rgb("14141e"),
+       "white":_rgb("f5f5fa")}
+
+def palette(accent_hex):
+    a=_rgb(accent_hex)
+    p=dict(SEM)
+    p.update(accent=a, acc_dim=shade(a,-52), acc_deep=shade(a,-66),
+             acc_hot=shade(a,34), acc_spark=shade(a,72),
+             grey_d=shade(SEM["grey"],-42), green_d=shade(SEM["green"],-70),
+             amber_d=shade(SEM["amber"],-78), red_deep=shade(SEM["red"],-66))
+    return p
+
+# ------------------------------------------------------------------ motif ----
+class Motif:
+    """A 17x17 mark + the cell roles the animation vocabulary needs."""
+    def __init__(self, grid, core=None, dots=None, sparks=None):
+        self.grid=grid; self.N=len(grid); self.cx=self.cy=(self.N-1)/2
+        self.filled=[(x,y) for y in range(self.N) for x in range(self.N) if grid[y][x]]
+        self.core=core if core is not None else []
+        coreset=set(self.core)
+        ringc=[(x,y) for (x,y) in self.filled if (x,y) not in coreset]
+        # order ring cells by angle from top, clockwise — the animatable path
+        self.ring=sorted(ringc, key=lambda p:(math.atan2(p[1]-self.cy,p[0]-self.cx)+math.pi/2)%(2*math.pi))
+        self.dots=dots if dots is not None else []
+        self.sparks=sparks if sparks is not None else []
+    def ang(self,x,y): return (math.atan2(y-self.cy,x-self.cx))%(2*math.pi)
+
+    @staticmethod
+    def oneman():
+        g=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0],
+        [0,0,0,0,1,1,0,1,1,1,0,1,1,0,0,0,0],[0,0,0,1,1,1,0,1,1,1,0,1,1,1,0,0,0],
+        [0,0,1,1,1,1,0,1,1,1,0,1,1,1,1,0,0],[0,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1,0],
+        [0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0],[0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0],
+        [0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1,0],[0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0],
+        [0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0],[0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0],
+        [0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,0,0],[0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0],
+        [0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0],[0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
+        core=[(x,y) for y in range(17) for x in range(17) if g[y][x] and x in (7,8,9) and y<=9]
+        dots=[(6,10),(8,10),(10,10)]
+        sparks_lv=[[],[(8,0),(1,5),(15,5),(0,8),(16,8)],
+                   [(8,0),(7,0),(9,0),(1,4),(15,4),(0,8),(16,8),(1,12),(15,12)]]
+        m=Motif(g, core=core, dots=dots, sparks=sparks_lv); return m
+
+# --------------------------------------------------------------- badges ------
+GLYPH = {
+ "dot":["00000","00000","00100","00000","00000"],"check":["00000","00001","00010","10100","01000"],
+ "x":["10001","01010","00100","01010","10001"],"pause":["01010","01010","01010","01010","01010"],
+ "slash":["00001","00010","00100","01000","10000"],"clock":["01110","10101","10111","10001","01110"],
+ "lock":["01110","01010","11111","11011","11111"],"shield":["11111","11111","01110","01110","00100"],
+ "up":["00100","01110","11111","00100","00100"],"gear":["01010","11111","01110","11111","01010"],
+}
+def put_badge(px, name, bg, fg, N):
+    for yy in range(0,6):
+        for xx in range(11, min(17,N)): px[(xx,yy)]=None
+    g=GLYPH[name]
+    for r in range(5):
+        for c in range(5): px[(12+c,r)] = fg if g[r][c]=="1" else bg
+
+# ------------------------------------------------- animation primitives ------
+# Each returns {(x,y): rgb|None} for frame t of nf. `col` is the state's base.
+def _fillall(m,col): return {p:col for p in m.filled}
+def tri(t,nf): x=(2*t/nf); return x if x<=1 else 2-x        # 0..1..0 triangle
+
+def mo_breathe(m,col,t,nf,P,amt=16):
+    return _fillall(m, shade(col, amt*tri(t,nf)))
+def mo_breathe_slow(m,col,t,nf,P): return mo_breathe(m,col,t,nf,P,amt=10)
+def mo_pulse(m,col,t,nf,P):
+    k=tri(t,nf); return _fillall(m, tuple(round(col[i]+(P["acc_hot"][i] if col==P["accent"] else shade(col,55)[i]-col[i])*0 + (shade(col,42)[i]-col[i])*k) for i in range(3)))
+def mo_blink(m,col,t,nf,P): return _fillall(m, col if t%2==0 else shade(col,-60))
+def mo_arc(m,col,t,nf,P,win=80,hot=None):
+    px=_fillall(m,P["acc_dim"]); hot=hot or P["acc_hot"]; ang0=(t/nf)*2*math.pi; w=math.radians(win)
+    for (x,y) in m.ring:
+        a=m.ang(x,y); da=min((a-ang0)%(2*math.pi),(ang0-a)%(2*math.pi))
+        if da<=w/2: px[(x,y)]=hot
+    for p in m.core: px[p]=col
+    return px
+def mo_scan(m,col,t,nf,P): return mo_arc(m,col,t,nf,P,win=34,hot=P["acc_spark"])
+def mo_spin(m,col,t,nf,P): return mo_arc(m,col,t,nf,P,win=54)
+def mo_dualarc(m,col,t,nf,P):
+    px=_fillall(m,P["acc_dim"]); ang0=(t/nf)*2*math.pi; w=math.radians(70)
+    for (x,y) in m.ring:
+        a=m.ang(x,y)
+        for b in (ang0,ang0+math.pi):
+            if min((a-b)%(2*math.pi),(b-a)%(2*math.pi))<=w/2: px[(x,y)]=P["acc_hot"]
+    for p in m.core: px[p]=col
+    return px
+def mo_fill(m,col,t,nf,P,core_from=0.0):
+    px=_fillall(m,P["acc_dim"]); prog=(t+1)/nf
+    for (x,y) in m.ring:
+        a=(m.ang(x,y)+math.pi/2)%(2*math.pi)
+        if a/(2*math.pi)<=prog: px[(x,y)]=col
+    for p in m.core:
+        if prog>=core_from: px[p]=col
+    return px
+def mo_boot(m,col,t,nf,P): return mo_fill(m,col,t,nf,P,core_from=0.7)
+def mo_dots(m,col,t,nf,P):
+    px=_fillall(m,col); lit=t%max(1,len(m.dots))
+    for i,p in enumerate(m.dots): px[p]=P["acc_spark"] if i==lit else P["acc_deep"]
+    return px
+def mo_sparkout(m,col,t,nf,P):
+    px=_fillall(m,col); step=[0,1,2,1][t%4]
+    for p in m.sparks[step]: px[p]=P["acc_spark"] if step==2 else P["acc_hot"]
+    return px
+def mo_sparkin(m,col,t,nf,P):
+    px=_fillall(m,col); step=[2,1,0,1][t%4]
+    for p in m.sparks[step]: px[p]=P["acc_spark"]
+    return px
+def mo_celebrate(m,col,t,nf,P):
+    cyc=[P["green"],P["amber"],P["accent"],P["acc_spark"]]
+    px=_fillall(m,cyc[t%len(cyc)]); step=[0,1,2,2][t%4]
+    for p in m.sparks[step]: px[p]=P["acc_spark"] if t%2 else P["white"]
+    return px
+
+MOTION = {"breathe":mo_breathe,"breathe_slow":mo_breathe_slow,"pulse":mo_pulse,"blink":mo_blink,
+ "arc":mo_arc,"scan":mo_scan,"spin":mo_spin,"dualarc":mo_dualarc,"fill":mo_fill,"boot":mo_boot,
+ "dots":mo_dots,"sparkout":mo_sparkout,"sparkin":mo_sparkin,"celebrate":mo_celebrate}
+
+# ------------------------------------------------- state catalog (32) --------
+# state: (group, colour-role, motion, badge|None, fps)
+A="accent"
+CATALOG = {
+ # power / lifecycle
+ "off":("power","grey","breathe_slow",None,6),      "booting":("power",A,"boot",None,8),
+ "idle":("power","acc_dim","breathe",None,6),        "active":("power",A,"breathe",None,7),
+ "paused":("power","amber","breathe",("pause","amber_d","white"),6),
+ "offline":("power","grey","breathe_slow",("slash","grey_d","white"),4),
+ # work / process
+ "thinking":("work",A,"arc",None,11),               "loading":("work",A,"fill",None,9),
+ "syncing":("work",A,"dualarc",None,10),            "writing":("work",A,"dots",None,5),
+ "streaming":("work",A,"pulse",None,6),             "queued":("work","amber","breathe",("clock","amber_d","white"),6),
+ "scanning":("work",A,"scan",None,16),              "deploying":("work",A,"fill",("up","ink","white"),9),
+ # communication
+ "speaking":("comms",A,"sparkout",None,5),          "listening":("comms","blue","sparkin",None,5),
+ "notification":("comms",A,"pulse",("dot","white","accent"),6),
+ "mention":("comms","blue","pulse",("dot","white","blue"),6),
+ "recording":("comms","red","pulse",("dot","white","red"),7),
+ # outcomes
+ "success":("outcome","green","breathe",None,7),    "warning":("outcome","amber","pulse",None,6),
+ "critical":("outcome","red","blink",None,2),       "blocked":("outcome","red","blink",("lock","ink","white"),2),
+ "error":("outcome","red","blink",("x","ink","white"),2),
+ "retrying":("outcome",A,"spin",None,12),
+ # governance / domain
+ "awaiting":("gov","amber","breathe",("clock","amber_d","white"),5),
+ "approved":("gov","green","breathe",("check","white","green"),7),
+ "rejected":("gov","red","breathe",("x","ink","white"),6),
+ "secure":("gov","green","breathe",("shield","green_d","white"),7),
+ "vulnerable":("gov","red","pulse",("shield","ink","white"),6),
+ "maintenance":("gov","grey","breathe",("gear","grey_d","white"),5),
+ "celebrating":("gov","green","celebrate",None,7),
+}
+GROUPS=["power","work","comms","outcome","gov"]
+
+def _color(role,P): return P[role] if role in P else P.get(role, P["accent"])
+
+def frames_for(m,state,P):
+    grp,role,motion,badge,fps=CATALOG[state]
+    col=_color(role,P); fn=MOTION[motion]
+    nf={"breathe":10,"breathe_slow":10,"pulse":8,"blink":2,"arc":12,"scan":12,"spin":10,
+        "dualarc":12,"fill":12,"boot":10,"dots":max(2,len(m.dots)*2),"sparkout":4,"sparkin":4,"celebrate":8}[motion]
+    out=[]
+    for t in range(nf):
+        px=fn(m,col,t,nf,P)
+        if badge:
+            nm,bg,fg=badge
+            put_badge(px, nm, P[bg], P[fg], m.N)
+        out.append(px)
+    return out, fps
+
+# ------------------------------------------------------------- renderers -----
+def render(px,N,scale):
+    img=Image.new("RGBA",(N*scale,N*scale),(0,0,0,0)); d=ImageDraw.Draw(img)
+    for (x,y),c in px.items():
+        if c is not None: d.rectangle([x*scale,y*scale,(x+1)*scale-1,(y+1)*scale-1],fill=c+(255,))
+    return img
+def svg_of(px,N):
+    from collections import defaultdict
+    by=defaultdict(list)
+    for (x,y),c in px.items():
+        if c is not None: by[c].append((x,y))
+    parts=[]
+    for c,cells in by.items():
+        rs="".join(f'<rect x="{x}" y="{y}" width="1" height="1"/>' for x,y in sorted(cells))
+        parts.append(f'<g fill="#%02x%02x%02x">{rs}</g>'%c)
+    return (f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {N} {N}" '
+            f'shape-rendering="crispEdges" role="img">{"".join(parts)}</svg>\n')
+
+def generate(m:Motif, accent="#ff1212", out="oneman", title="ONEMAN", scale=9):
+    P=palette(accent); base=os.path.join(OUT_BASE, out); os.makedirs(base, exist_ok=True)
+    meta={"title":title,"accent":accent,"N":m.N,"scale":scale,"groups":GROUPS,"states":{}}
+    for s in CATALOG:
+        frames,fps=frames_for(m,s,P)
+        imgs=[render(px,m.N,scale) for px in frames]
+        w=sum(i.width for i in imgs); strip=Image.new("RGBA",(w,imgs[0].height),(0,0,0,0)); x=0
+        for i in imgs: strip.paste(i,(x,0)); x+=i.width
+        strip.save(os.path.join(base,f"anim-{s}.png"))
+        open(os.path.join(base,f"mark-{s}.svg"),"w").write(svg_of(frames[0],m.N))  # still fallback
+        grp,role,motion,badge,_=CATALOG[s]
+        meta["states"][s]={"group":grp,"frames":len(frames),"fps":fps,"motion":motion,
+                           "badge":badge[0] if badge else None}
+    # overview sheet (representative frame 2 of each)
+    cols,rows,cell=8,4,7; tile=m.N*cell; pad=cell
+    sheet=Image.new("RGBA",(cols*tile+(cols+1)*pad,rows*tile+(rows+1)*pad),(16,16,24,255))
+    order=[s for g in GROUPS for s in CATALOG if CATALOG[s][0]==g]
+    def rep_idx(motion,n):
+        return {"blink":0,"fill":int(n*0.62),"boot":int(n*0.62),"arc":n//4,"scan":n//4,
+                "spin":n//4,"dualarc":n//4,"dots":1}.get(motion, n//2)
+    for i,s in enumerate(order):
+        fr,_=frames_for(m,s,P); im=render(fr[rep_idx(CATALOG[s][2],len(fr))],m.N,cell)
+        cx=pad+(i%cols)*(tile+pad); cy=pad+(i//cols)*(tile+pad); sheet.paste(im,(cx,cy),im)
+    sheet.save(os.path.join(base,"sprite-sheet.png"))
+    json.dump(meta, open(os.path.join(base,"states.json"),"w"), indent=1)
+    return meta
+
+if __name__=="__main__":
+    meta=generate(Motif.oneman(), accent="#ff1212", out="oneman", title="ONEMAN")
+    print(f"{title if (title:=meta['title']) else ''}: {len(meta['states'])} states, all animated")
+    print("groups:", ", ".join(GROUPS))
+    print("states:", ", ".join(meta["states"]))