@a-t-h-i/bot-lobby 0.3.0 → 0.5.0

package/src/pi/kaomoji.ts

@@ -0,0 +1,227 @@
+/**
+ * The agents' kaomoji: a pure catalogue of emotes and the rules that pick one.
+ *
+ * Every emote is a tiny animation: the open face, the same face blinking (same
+ * width, so nothing shifts), and an optional action frame (a table flip, a
+ * sparkle, a bow). Each agent has its own personality set for every emotion,
+ * and a shared pool of emotions is open to all of them:
+ *
+ * - DEV, the hacker: shades, flexing, coffee, and table flips on failure
+ * - DESIGN, the artist: sparkles, flowers, hearts and little flourishes
+ * - RESEARCH, the bookworm: note-taking, pointing, shrugging, deal-with-it glasses
+ * - QA, the inspector: side-eyes and squints, then a flex and a victory dance
+ *
+ * Nothing here reads a clock or a random source: the caller passes a `variant`
+ * drawn once per expression, so the same variant always picks the same face.
+ * Every face fits a slot cell and avoids combining marks, right-to-left
+ * scripts and emoji-presentation glyphs (enforced by tests).
+ */
+import type { SlotId, SlotState } from "./mascot-art.ts";
+
+export const EMOTIONS = [
+  "happy",
+  "proud",
+  "love",
+  "excited",
+  "focused",
+  "curious",
+  "thinking",
+  "nervous",
+  "confused",
+  "sleepy",
+  "sad",
+  "angry",
+  "waiting",
+  "surprised",
+  "grateful",
+] as const;
+export type Emotion = (typeof EMOTIONS)[number];
+
+/** One emote: the open face, the same face blinking, and an optional action frame. */
+export interface Emote {
+  open: string;
+  blink: string;
+  action?: string;
+}
+
+const e = (open: string, blink: string, action?: string): Emote => (action ? { open, blink, action } : { open, blink });
+
+/** Emotions every agent can draw on. */
+export const SHARED_EMOTES: Record<Emotion, readonly Emote[]> = {
+  happy: [e("(^▽^)", "(-▽-)"), e("(＾ω＾)", "(－ω－)"), e("ヽ(•‿•)ノ", "ヽ(-‿-)ノ"), e("(*^‿^*)", "(*-‿-*)"), e("(◕‿◕)", "(-‿-)")],
+  proud: [e("(￣^￣)ゞ", "(－^－)ゞ"), e("(´▽`)b", "(-▽-)b"), e("( ￣ー￣)", "( －ー－)"), e("(•ᴗ•)ง", "(-ᴗ-)ง")],
+  love: [e("(♡‿♡)", "(-‿-)", "(♡‿♡)♡"), e("(っ˘з(˘⌣˘ )", "(っ-з(-⌣- )"), e("(´ε｀ )♡", "(-ε－ )♡"), e("(◍•ᴗ•◍)♡", "(◍-ᴗ-◍)♡")],
+  excited: [e("\\(^o^)/", "\\(-o-)/"), e("ヽ(^▽^)ノ", "ヽ(-▽-)ノ"), e("(ﾉ◕ヮ◕)ﾉ", "(ﾉ-ヮ-)ﾉ", "(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧"), e("o(≧▽≦)o", "o(-▽-)o")],
+  focused: [e("(•_•)", "(-_-)"), e("(ง •_•)ง", "(ง -_-)ง"), e("(｀・ω・´)", "(｀－ω－´)"), e("( ._.)φ", "( -_-)φ")],
+  curious: [e("(・・ )?", "(－－ )?"), e("(⊙_⊙)?", "(-_-)?"), e("(◔_◔)", "(-_-)"), e("(ﾟ∀ﾟ)?", "(-∀-)?")],
+  thinking: [e("(￣～￣;)", "(－～－;)"), e("( ˘_˘ )", "( -_- )"), e("(・・;)ゞ", "(－－;)ゞ"), e("(¬‿¬ )", "(-‿- )")],
+  nervous: [e("(；・∀・)", "(；－∀－)"), e("(⊙﹏⊙)", "(-﹏-)"), e("(●´⌓`●)", "(●-⌓-●)"), e("(°□°;)", "(-□-;)")],
+  confused: [e("(・_・ヾ", "(－_－ヾ"), e("(⊙_☉)", "(-_-)"), e("(゜-゜)", "(－-－)"), e("(・・?)", "(－－?)")],
+  sleepy: [e("(-_-) zzZ", "(-.-) zzZ"), e("(￣o￣) zzZZ", "(－o－) zzZZ"), e("(∪｡∪)｡zz", "(-｡-)｡zz"), e("( ˘ω˘ )ｽﾔｧ", "( -ω- )ｽﾔｧ")],
+  sad: [e("(ಥ_ಥ)", "(-_-)"), e("(╥﹏╥)", "(-﹏-)"), e("(´;ω;`)", "(-;ω;-)"), e("(〒﹏〒)", "(－﹏－)"), e("(T_T)", "(-_-)")],
+  angry: [e("(╬ಠ益ಠ)", "(╬-益-)"), e("(ノಠ益ಠ)ノ", "(ノ-益-)ノ", "(ノಠ益ಠ)ノ彡┻━┻"), e("ヽ(`Д´)ﾉ", "ヽ(-Д-)ﾉ"), e("(¬_¬\")", "(-_-\")")],
+  waiting: [e("(´･_･`)", "(´-_-`)"), e("( ˘･_･˘)", "( ˘-_-˘)"), e("(っ´ω`c)", "(っ-ω-c)"), e("(・_・)…", "(－_－)…")],
+  surprised: [e("(°o°)", "(-o-)"), e("Σ(°△°|||)", "Σ(-△-|||)"), e("(ﾟДﾟ)", "(-Д-)"), e("w(°ｏ°)w", "w(-ｏ-)w")],
+  grateful: [e("(人´∀`)", "(人-∀-)"), e("(◍•ᴗ•◍)", "(◍-ᴗ-◍)"), e("m(_ _)m", "m(- -)m"), e("(ᵔᴥᵔ)", "(-ᴥ-)"), e("(*´∀`*)", "(*-∀-*)")],
+};
+
+/** DEV, the hacker: shades, flexes, coffee and code brackets; flips tables when things break. */
+const DEV: Record<Emotion, readonly Emote[]> = {
+  happy: [e("(⌐■_■)", "(⌐-_-)"), e("(^_^)b", "(-_-)b"), e("</>(^▽^)", "</>(-▽-)"), e("( •_•)c[_]", "( -_-)c[_]")],
+  proud: [e("(⌐■_■)b", "(⌐-_-)b"), e("ᕦ(ò_óˇ)ᕤ", "ᕦ(-_-ˇ)ᕤ"), e("( •_•)>⌐■-■", "( -_-)>⌐■-■", "(⌐■_■)"), e("b(￣▽￣)d", "b(－▽－)d")],
+  love: [e("(♡_♡)</>", "(-_-)</>"), e("(´∀`)♡{ }", "(-∀-)♡{ }"), e("(˘▽˘)c[_]", "(-▽-)c[_]"), e("(◍•_•◍)♡", "(◍-_-◍)♡")],
+  excited: [e("ᕦ(ò_ó)ᕤ", "ᕦ(-_-)ᕤ"), e("(ﾉ≧∀≦)ﾉ", "(ﾉ-∀-)ﾉ", "(ﾉ≧∀≦)ﾉ</>"), e("\\(•_•)/", "\\(-_-)/"), e("(⌐■▽■)", "(⌐-▽-)")],
+  focused: [e("(•_•)>_", "(-_-)>_"), e("[•_•]$_", "[-_-]$_"), e("(ง'-')ง", "(ง- -)ง"), e("(⌐■_■)>_", "(⌐-_-)>_")],
+  curious: [e("(•_•)?</>", "(-_-)?</>"), e("(・_・)ﾉ{ }", "(－_－)ﾉ{ }"), e("(°_°)>_", "(-_-)>_"), e("( ⊙_⊙)</>", "( -_-)</>")],
+  thinking: [e("(￣_￣)c[_]", "(－_－)c[_]"), e("( •_•)…{ }", "( -_-)…{ }"), e("(¬_¬)>_", "(-_-)>_"), e("(°～°)</>", "(-～-)</>")],
+  nervous: [e("(°_°;)>_", "(-_-;)>_"), e("(・_・;)$_", "(－_－;)$_"), e("(⊙_⊙;)", "(-_-;)"), e("(ﾟ_ﾟ;)c[_]", "(-_-;)c[_]")],
+  confused: [e("(・_・)?{ }", "(－_－)?{ }"), e("(°_°)?>_", "(-_-)?>_"), e("(⊙_☉)</>", "(-_-)</>"), e("(゜_゜)$?", "(－_－)$?")],
+  sleepy: [e("(-_-)c[_] z", "(-.-)c[_] z"), e("(￣o￣)>_ zz", "(－o－)>_ zz"), e("(∪_∪)</> z", "(-_-)</> z"), e("( ˘_˘ )$_ z", "( -_- )$_ z")],
+  sad: [e("(╥_╥)>_", "(-_-)>_"), e("(T_T)</>", "(-_-)</>"), e("(ಥ_ಥ)c[_]", "(-_-)c[_]"), e("(´;_;`)$_", "(-;_;-)$_")],
+  angry: [e("(╯°□°)╯", "(╯-□-)╯", "(╯°□°)╯︵ ┻━┻"), e("(ノಠ益ಠ)ノ", "(ノ-益-)ノ", "(ノಠ益ಠ)ノ彡┻━┻"), e("(╬ò_ó)>_", "(╬-_-)>_"), e("┻━┻ ︵ (°□°)", "┻━┻ ︵ (-□-)")],
+  waiting: [e("(•_•)c[_]", "(-_-)c[_]"), e("(´･_･`)>_", "(´-_-`)>_"), e("( ˘_˘)</>…", "( -_-)</>…"), e("(・_・)$_…", "(－_－)$_…")],
+  surprised: [e("(°□°)>_", "(-□-)>_"), e("Σ(°_°)</>", "Σ(-_-)</>"), e("(ﾟДﾟ)$_", "(-Д-)$_"), e("(⊙_⊙)!{ }", "(-_-)!{ }")],
+  grateful: [e("(⌐■_■)b", "(⌐-_-)b"), e("m(_ _)m</>", "m(- -)m</>"), e("(^_^)c[_]", "(-_-)c[_]"), e("(人•_•)", "(人-_-)")],
+};
+
+/** DESIGN, the artist: sparkles, flowers, hearts and a little flourish on most things. */
+const DESIGN: Record<Emotion, readonly Emote[]> = {
+  happy: [e("✧(◕‿◕✿)", "✧(-‿-✿)"), e("(✿^‿^)", "(✿-‿-)"), e("(◕ᴗ◕✿)", "(-ᴗ-✿)"), e("❀(^▽^)❀", "❀(-▽-)❀")],
+  proud: [e("(✿◠‿◠)", "(✿-‿-)"), e("✧(˘▽˘)✧", "✧(-▽-)✧"), e("(￣▽￣)✿", "(－▽－)✿"), e("(◕‿◕)b✧", "(-‿-)b✧")],
+  love: [e("(♡‿♡)✿", "(-‿-)✿"), e("(っ˘з˘)♡✧", "(っ-з-)♡✧"), e("(◍♡‿♡◍)", "(◍-‿-◍)"), e("✿(´ε｀)♡", "✿(-ε－)♡")],
+  excited: [e("(ﾉ◕ヮ◕)ﾉ", "(ﾉ-ヮ-)ﾉ", "(ﾉ◕ヮ◕)ﾉ*:･ﾟ✧"), e("✧*(^▽^)*✧", "✧*(-▽-)*✧"), e("☆(≧▽≦)☆", "☆(-▽-)☆"), e("♪(^∇^)♪", "♪(-∇-)♪")],
+  focused: [e("(•‿•)~✎", "(-‿-)~✎"), e("( ˘_˘)~✿", "( -_-)~✿"), e("(◕_◕)✎", "(-_-)✎"), e("(・ω・)~♪", "(－ω－)~♪")],
+  curious: [e("(◕_◕)?✧", "(-_-)?✧"), e("(・・ )✿?", "(－－ )✿?"), e("(°‿°)?", "(-‿-)?"), e("✧(◔_◔)", "✧(-_-)")],
+  thinking: [e("( ˘‿˘)~✎", "( -‿-)~✎"), e("(￣～￣)✿", "(－～－)✿"), e("(◕～◕)…", "(-～-)…"), e("(・・)~♪", "(－－)~♪")],
+  nervous: [e("(◕﹏◕✿)", "(-﹏-✿)"), e("(°‿°;)✎", "(-‿-;)✎"), e("(・_・;)✿", "(－_－;)✿"), e("(⊙‿⊙;)", "(-‿-;)")],
+  confused: [e("(◕_◕)?~", "(-_-)?~"), e("(・・?)✿", "(－－?)✿"), e("(゜‿゜)?", "(－‿－)?"), e("(°_°)✎?", "(-_-)✎?")],
+  sleepy: [e("(-‿-)✿ zz", "(-.-)✿ zz"), e("( ˘ω˘ )✿z", "( -ω- )✿z"), e("(∪‿∪)♪ z", "(-‿-)♪ z"), e("(￣‿￣)zzZ", "(－‿－)zzZ")],
+  sad: [e("(╥﹏╥)✿", "(-﹏-)✿"), e("(ಥ‿ಥ)", "(-‿-)"), e("(´;ω;`)✎", "(-;ω;-)✎"), e("(◕︵◕)", "(-︵-)")],
+  angry: [e("(╬◣_◢)", "(╬-_-)"), e("(ﾉ｀Д´)ﾉ✎", "(ﾉ－Д-)ﾉ✎"), e("(¬_¬)✿", "(-_-)✿"), e("(ಠ‿ಠ)✎", "(-‿-)✎")],
+  waiting: [e("(っ´ω`c)✿", "(っ-ω-c)✿"), e("( ˘‿˘)~♪", "( -‿-)~♪"), e("(・‿・)…✿", "(－‿－)…✿"), e("(´･‿･`)", "(´-‿-`)")],
+  surprised: [e("(°o°)✿", "(-o-)✿"), e("✧(⊙‿⊙)✧", "✧(-‿-)✧"), e("(ﾟ∀ﾟ)!✎", "(-∀-)!✎"), e("Σ(◕o◕)", "Σ(-o-)")],
+  grateful: [e("(人◕‿◕)", "(人-‿-)"), e("(◍•ᴗ•◍)✿", "(◍-ᴗ-◍)✿"), e("✿m(_ _)m", "✿m(- -)m"), e("(*´▽`*)✧", "(*-▽-*)✧")],
+};
+
+/** RESEARCH, the bookworm: takes notes, points at things, shrugs at the unknown. */
+const RESEARCH: Record<Emotion, readonly Emote[]> = {
+  happy: [e("φ(^▽^)", "φ(-▽-)"), e("(^_^)[ ]", "(-_-)[ ]"), e("(•‿•)φ", "(-‿-)φ"), e("( ˘▽˘)ﾉ", "( -▽-)ﾉ")],
+  proud: [e("( •_•)>⌐■-■", "( -_-)>⌐■-■", "(⌐■_■)"), e("(￣^￣)φ", "(－^－)φ"), e("(•ᴗ•)b[ ]", "(-ᴗ-)b[ ]"), e("( ￣ー￣)φ", "( －ー－)φ")],
+  love: [e("(♡_♡)[ ]", "(-_-)[ ]"), e("φ(´∀`)♡", "φ(-∀-)♡"), e("(◍•_•◍)φ", "(◍-_-◍)φ"), e("(˘ε˘)♡[ ]", "(-ε-)♡[ ]")],
+  excited: [e("(σ・・)σ!", "(σ－－)σ!"), e("φ(≧▽≦)", "φ(-▽-)"), e("\\(°o°)/", "\\(-o-)/"), e("(ﾉ°▽°)ﾉ[ ]", "(ﾉ-▽-)ﾉ[ ]")],
+  focused: [e("φ(．．)", "φ(－－)", "φ(．．;)"), e("( ._.)φ__", "( -_-)φ__"), e("(・_・)[ ]", "(－_－)[ ]"), e("( •_•)φ", "( -_-)φ")],
+  curious: [e("(σ・・)σ", "(σ－－)σ"), e("(・・ )?[ ]", "(－－ )?[ ]"), e("(⊙_⊙)φ?", "(-_-)φ?"), e("(°_°)…?", "(-_-)…?")],
+  thinking: [e("φ(￣～￣)", "φ(－～－)"), e("( ˘_˘ )φ", "( -_- )φ"), e("(・・;)[ ]", "(－－;)[ ]"), e("(¬_¬)φ…", "(-_-)φ…")],
+  nervous: [e("φ(°_°;)", "φ(-_-;)"), e("(・_・;)[?]", "(－_－;)[?]"), e("(⊙﹏⊙)φ", "(-﹏-)φ"), e("(°□°;)[ ]", "(-□-;)[ ]")],
+  confused: [e("¯\\_(ツ)_/¯", "¯\\_(ー)_/¯"), e("(・_・ヾ[?]", "(－_－ヾ[?]"), e("(⊙_☉)φ", "(-_-)φ"), e("(゜-゜)?[ ]", "(－-－)?[ ]")],
+  sleepy: [e("(-_-)[ ] zz", "(-.-)[ ] zz"), e("φ(￣o￣) z", "φ(－o－) z"), e("(∪_∪)φ zz", "(-_-)φ zz"), e("( ˘ω˘ )[ ]z", "( -ω- )[ ]z")],
+  sad: [e("(ಥ_ಥ)φ", "(-_-)φ"), e("(╥_╥)[ ]", "(-_-)[ ]"), e("(´;ω;`)φ", "(-;ω;-)φ"), e("(T_T)[?]", "(-_-)[?]")],
+  angry: [e("(ಠ_ಠ)φ", "(-_-)φ"), e("(╬ಠ_ಠ)[ ]", "(╬-_-)[ ]"), e("ヽ(`Д´)ﾉφ", "ヽ(-Д-)ﾉφ"), e("(¬_¬\")[ ]", "(-_-\")[ ]")],
+  waiting: [e("(´･_･`)φ", "(´-_-`)φ"), e("( ˘･_･˘)[ ]", "( ˘-_-˘)[ ]"), e("φ(・_・)…", "φ(－_－)…"), e("(っ´ω`c)φ", "(っ-ω-c)φ")],
+  surprised: [e("Σ(°o°)φ", "Σ(-o-)φ"), e("(ﾟДﾟ)[!]", "(-Д-)[!]"), e("(⊙_⊙)!φ", "(-_-)!φ"), e("w(°ｏ°)w[ ]", "w(-ｏ-)w[ ]")],
+  grateful: [e("(人´∀`)φ", "(人-∀-)φ"), e("m(_ _)m[ ]", "m(- -)m[ ]"), e("(ᵔᴥᵔ)φ", "(-ᴥ-)φ"), e("(◍•ᴗ•◍)[ ]", "(◍-ᴗ-◍)[ ]")],
+};
+
+/** QA, the inspector: side-eyes and squints at everything, then flexes and dances on a pass. */
+const QA: Record<Emotion, readonly Emote[]> = {
+  happy: [e("(•‿•)✓", "(-‿-)✓"), e("( ^_^)[✓]", "( -_-)[✓]"), e("(ᵔ.ᵔ)✓", "(-.-)✓"), e("(＾_＾)✓", "(－_－)✓")],
+  proud: [e("ᕙ( • ‿ • )ᕗ", "ᕙ( - ‿ - )ᕗ"), e("ᕦ(•_•)ᕤ✓", "ᕦ(-_-)ᕤ✓"), e("(￣^￣)✓", "(－^－)✓"), e("( •_•)b✓", "( -_-)b✓")],
+  love: [e("(♡_♡)✓", "(-_-)✓"), e("(´∀`)♡[✓]", "(-∀-)♡[✓]"), e("(◍•_•◍)✓", "(◍-_-◍)✓"), e("(˘ε˘)♡✓", "(-ε-)♡✓")],
+  excited: [e("ᕕ( ᐛ )ᕗ", "ᕕ( - )ᕗ"), e("\\(•_•)/✓", "\\(-_-)/✓"), e("(ﾉ≧▽≦)ﾉ✓", "(ﾉ-▽-)ﾉ✓"), e("ᕙ(⇀‸↼)ᕗ", "ᕙ(-‸-)ᕗ")],
+  focused: [e("(ಠ_ಠ)", "(−_−)"), e("(¬_¬)", "(-_-)"), e("(눈_눈)", "(－_－)"), e("(•_•)⊙", "(-_-)⊙")],
+  curious: [e("(ಠ_ಠ)?", "(−_−)?"), e("(¬_¬)?[ ]", "(-_-)?[ ]"), e("(⊙_⊙)⊙", "(-_-)⊙"), e("(・_・)?✓", "(－_－)?✓")],
+  thinking: [e("(¬‿¬)[ ]", "(-‿-)[ ]"), e("(ಠ～ಠ)", "(−～−)"), e("(￣_￣)[?]", "(－_－)[?]"), e("( ˘_˘ )✓?", "( -_- )✓?")],
+  nervous: [e("(ಠ_ಠ;)", "(−_−;)"), e("(°_°;)[ ]", "(-_-;)[ ]"), e("(⊙﹏⊙)✓?", "(-﹏-)✓?"), e("(・_・;)✗?", "(－_－;)✗?")],
+  confused: [e("(ಠ_ಠ)?!", "(−_−)?!"), e("(・_・ヾ[?]", "(－_－ヾ[?]"), e("(⊙_☉)✗", "(-_-)✗"), e("(゜-゜)[✗]", "(－-－)[✗]")],
+  sleepy: [e("(-_-)[ ] zz", "(-.-)[ ] zz"), e("(￣o￣)✓ zz", "(－o－)✓ zz"), e("(∪_∪)⊙ z", "(-_-)⊙ z"), e("( ˘ω˘ )✓z", "( -ω- )✓z")],
+  sad: [e("(ಥ_ಥ)✗", "(-_-)✗"), e("(╥﹏╥)[✗]", "(-﹏-)[✗]"), e("(´;ω;`)✗", "(-;ω;-)✗"), e("(T_T)✗", "(-_-)✗")],
+  angry: [e("(ಠ益ಠ)", "(−益−)"), e("(╬ಠ_ಠ)✗", "(╬−_−)✗"), e("(ノಠ益ಠ)ノ", "(ノ−益−)ノ", "(ノಠ益ಠ)ノ[✗]"), e("(¬_¬\")✗", "(-_-\")✗")],
+  waiting: [e("(¬_¬)…", "(-_-)…"), e("(´･_･`)[ ]", "(´-_-`)[ ]"), e("(ಠ_ಠ)…", "(−_−)…"), e("( ˘_˘)✓…", "( -_-)✓…")],
+  surprised: [e("(ಠ_ಠ)!", "(−_−)!"), e("Σ(°_°)✗", "Σ(-_-)✗"), e("(⊙_⊙)[!]", "(-_-)[!]"), e("(ﾟДﾟ)✓!", "(-Д-)✓!")],
+  grateful: [e("(人•_•)✓", "(人-_-)✓"), e("m(_ _)m✓", "m(- -)m✓"), e("(ᵔ.ᵔ)b", "(-.-)b"), e("(◍•ᴗ•◍)✓", "(◍-ᴗ-◍)✓")],
+};
+
+/** Personality sets per agent column. */
+export const PERSONALITY_EMOTES: Record<SlotId, Record<Emotion, readonly Emote[]>> = {
+  dev: DEV,
+  design: DESIGN,
+  research: RESEARCH,
+  qa: QA,
+};
+
+/** Frames per emote: open, blink, then the action (or the open face again), held one step each. */
+export const EMOTE_STEPS = 4;
+
+/** The four frames an emote steps through: open, blink, action, action. */
+export function emoteFrames(emote: Emote): readonly string[] {
+  const finish = emote.action ?? emote.open;
+  return [emote.open, emote.blink, finish, finish];
+}
+
+/** What a slot is going through, as far as its face is concerned. */
+export interface Situation {
+  status: SlotState;
+  /** Live one-word activity while working (reading, editing, running, thinking, ...). */
+  activity?: string;
+  flag?: "waiting" | "quiet" | "retry";
+  /** The run was asked to wrap up early. */
+  wrappedUp?: boolean;
+  /** A file was just handed to this agent. */
+  handover?: boolean;
+}
+
+const ACTIVITY_EMOTIONS: Record<string, readonly Emotion[]> = {
+  reading: ["curious", "focused"],
+  searching: ["curious", "thinking"],
+  editing: ["focused", "excited", "proud"],
+  running: ["nervous", "focused"],
+  thinking: ["thinking", "curious"],
+  writing: ["focused", "proud"],
+  researching: ["curious", "thinking"],
+};
+
+/** The emotions that fit a situation, most fitting first. */
+export function emotionsFor(situation: Situation): readonly Emotion[] {
+  switch (situation.status) {
+    case "idle":
+      return ["sleepy", "waiting", "happy"];
+    case "done":
+      return situation.wrappedUp ? ["nervous", "proud"] : ["happy", "proud", "love", "excited"];
+    case "failed":
+      return ["sad", "angry", "confused", "surprised"];
+    default:
+      break;
+  }
+  if (situation.flag === "waiting") return ["waiting"];
+  if (situation.flag === "quiet") return ["confused", "sleepy"];
+  if (situation.flag === "retry") return ["nervous", "sad"];
+  if (situation.handover) return ["grateful", "happy"];
+  if (situation.wrappedUp) return ["nervous", "surprised"];
+  return ACTIVITY_EMOTIONS[situation.activity ?? ""] ?? ["focused", "excited", "happy"];
+}
+
+/** Share of picks drawn from the agent's own personality set (out of 10). */
+const PERSONALITY_SHARE = 6;
+
+function positive(variant: number): number {
+  return Number.isFinite(variant) ? Math.abs(Math.floor(variant)) : 0;
+}
+
+/**
+ * The emote for one expression: the emotion from the situation, then a face
+ * from the agent's personality (about 60%) or the shared pool, all chosen by
+ * the expression's `variant`.
+ */
+export function pickEmote(slot: SlotId, situation: Situation, variant: number): Emote {
+  const seed = positive(variant);
+  const emotions = emotionsFor(situation);
+  const emotion = emotions[seed % emotions.length]!;
+  const own = (Math.floor(seed / 7) % 10) < PERSONALITY_SHARE;
+  const pool = own ? PERSONALITY_EMOTES[slot][emotion] : SHARED_EMOTES[emotion];
+  return pool[Math.floor(seed / 71) % pool.length]!;
+}
+
+/** The frames of the emote a slot plays for this expression. */
+export function slotEmote(slot: SlotId, situation: Situation, variant: number): readonly string[] {
+  return emoteFrames(pickEmote(slot, situation, variant));
+}

package/src/pi/mascot-art.ts

@@ -1,4 +1,5 @@
 import type { TaskState } from "../schemas/task.ts";
+import { slotEmote } from "./kaomoji.ts";
 
 /**
  * Pure ASCII art data for the scene-based zen panel. No logic lives here: the
@@ -258,33 +259,22 @@ const FACE_FRAMES: Record<SlotState, readonly string[]> = {
   failed: ["(>_<)", "(x_x)", "(T_T)", "(;_;)"],
 };
 
-/** Kaomoji emotes for the large scene: working nervous, done happy, failed scared. */
-const EMOTE_FACES: Record<SlotState, readonly string[]> = {
-  working: ["(٥↼_↼)", "(●´⌓`●)"],
-  idle: ["(-.-)", "(u.u)"],
-  done: ["(✿^‿^)", "(っ˘з(˘⌣˘ )"],
-  failed: ["ಥ_ಥ", "(〒﹏〒)"],
-};
-
-/** QA's success emotes are a flex and a victory dance rather than a smile. */
-const QA_DONE_FACES: readonly string[] = ["ᕙ( • ‿ • )ᕗ", "ᕕ( ᐛ )ᕗ"];
-
 /** Every compact face is five columns, so a centered column never shifts between frames. */
 export const FACE_WIDTH = 5;
 
 function buildSlotFrames(id: SlotId): Record<SlotState, readonly string[][]> {
   const frames = {} as Record<SlotState, readonly string[][]>;
   for (const state of SLOT_STATES) {
-    const emotes = id === "qa" && state === "done" ? QA_DONE_FACES : EMOTE_FACES[state];
-    frames[state] = [...FACE_FRAMES[state].slice(0, 2), ...emotes].map((face) => [face]);
+    frames[state] = [...FACE_FRAMES[state].slice(0, 2), ...slotEmote(id, { status: state }, 0)].map((face) => [face]);
   }
   return frames;
 }
 
 /**
  * Animated faces per slot: one row each. Rest (0) and blink (1) stay the five-column
- * ASCII eyes; the emote frames (2+) are status-aware kaomoji, wider than five columns,
- * so the scene centres each frame inside its fixed slot cell.
+ * ASCII eyes; the emote frames (2+) are the slot's default kaomoji for the status
+ * (open, blink, action). The live scene swaps in a situation-aware emote per
+ * expression (see kaomoji.ts); either way the scene centres each frame in its cell.
  */
 export const SLOT_FRAMES: Record<SlotId, Record<SlotState, readonly string[][]>> = {
   dev: buildSlotFrames("dev"),

package/src/pi/model-support.ts

@@ -0,0 +1,135 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  agentProfile,
+  isThinkingLevel,
+  lobbyAgentProfile,
+  panelMemberProfile,
+  type LobbyAgentKind,
+  type PanelMember,
+  THINKING_LEVELS,
+  type BotLobbyConfig,
+  type ProfileResolver,
+  type SubagentKind,
+  type ThinkingLevelName,
+} from "../schemas/configuration.ts";
+
+/** Find a model by `provider/id` (or bare id); undefined when the registry does not know it. */
+export type ModelLookup = (ref: string) => Model<Api> | undefined;
+
+export type { ProfileResolver };
+
+/** `provider/id` for a model, the form settings store. */
+export function modelRef(model: Pick<Model<Api>, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/** Thinking levels a model supports, in pi's order; every level when the model is unknown. */
+export function supportedThinking(model: Model<Api> | undefined): ThinkingLevelName[] {
+  if (!model) return [...THINKING_LEVELS];
+  return getSupportedThinkingLevels(model).filter((level): level is ThinkingLevelName => isThinkingLevel(level));
+}
+
+export interface ThinkingCheck {
+  /** The level to run at: the requested one, or pi's nearest supported level. */
+  level: string;
+  /** Set when the requested level had to change. */
+  warning?: string;
+}
+
+/** Clamp `level` to what `model` supports, explaining any change; unknown models pass through. */
+export function checkThinking(model: Model<Api> | undefined, level: string): ThinkingCheck {
+  if (!model || !isThinkingLevel(level)) return { level };
+  const clamped = clampThinkingLevel(model, level as ModelThinkingLevel);
+  if (clamped === level) return { level };
+  return { level: clamped, warning: `"${level}" thinking isn't supported by ${modelRef(model)} — using "${clamped}"` };
+}
+
+const LABELS: Record<SubagentKind | "master", string> = {
+  master: "Master",
+  designer: "Designer",
+  backend: "Backend",
+  qa: "QA",
+  scout: "Scout",
+  researcher: "Researcher",
+  quickfix: "Quick fix",
+  planner: "Planner",
+};
+
+export function kindLabel(kind: SubagentKind | "master"): string {
+  return LABELS[kind];
+}
+
+export interface ResolverOptions {
+  lookup: ModelLookup;
+  /** The session's model as `provider/id`; used only where settings name no model yet. */
+  sessionModel?: string;
+  /** Receives each distinct clamp warning once per process. */
+  warn?: (message: string) => void;
+}
+
+const warned = new Set<string>();
+
+/**
+ * Profiles straight from settings, with the thinking level clamped to what
+ * each model supports. A subagent whose model is still unset runs on the
+ * session's model (named explicitly on the command line) until settings pin one.
+ */
+export function createProfileResolver(config: BotLobbyConfig, options: ResolverOptions): ProfileResolver {
+  return (domain, role) => {
+    const profile = agentProfile(config, domain, role);
+    const model = profile.model ?? options.sessionModel;
+    const check = checkThinking(model ? options.lookup(model) : undefined, profile.thinking);
+    if (check.warning) {
+      const message = `bot-lobby: ${kindLabel(profile.kind)} — ${check.warning}. Change it in /bot-lobby settings.`;
+      if (!warned.has(message)) {
+        warned.add(message);
+        options.warn?.(message);
+      }
+    }
+    return { ...profile, model, thinking: check.level };
+  };
+}
+
+type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string };
+
+/** Unset models run on the session's; thinking is clamped to the model, with a one-time warning. */
+function resolveRunProfile(profile: RunProfile, label: string, options: ResolverOptions): RunProfile {
+  const model = profile.model ?? options.sessionModel;
+  const check = checkThinking(model ? options.lookup(model) : undefined, profile.thinking);
+  if (check.warning) {
+    const message = `bot-lobby: ${label} — ${check.warning}. Change it in /bot-lobby settings.`;
+    if (!warned.has(message)) {
+      warned.add(message);
+      options.warn?.(message);
+    }
+  }
+  return { ...profile, model, thinking: check.level };
+}
+
+/** A lobby agent's model, thinking and time limit. */
+export function resolveLobbyProfile(config: BotLobbyConfig, kind: LobbyAgentKind, options: ResolverOptions): RunProfile {
+  return resolveRunProfile(lobbyAgentProfile(config, kind), kindLabel(kind), options);
+}
+
+/** A planning panel seat's model, thinking and time limit, from its domain's (or the researcher's) settings. */
+export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember, options: ResolverOptions): RunProfile {
+  return resolveRunProfile(panelMemberProfile(config, member), kindLabel(member), options);
+}
+
+/** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */
+export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup, sessionModel?: string): string[] {
+  const entries: Array<[SubagentKind | "master", string, string]> = [
+    ["master", config.master.model, config.master.thinking],
+    ["designer", config.agents.designer.model, config.agents.designer.thinking],
+    ["backend", config.agents.backend.model, config.agents.backend.thinking],
+    ["qa", config.agents.qa.model, config.agents.qa.thinking],
+    ["researcher", config.researcher.model, config.researcher.thinking],
+    ["quickfix", config.quickFix.model, config.quickFix.thinking],
+    ["planner", config.planner.model, config.planner.thinking],
+  ];
+  return entries.flatMap(([kind, ref, level]) => {
+    const model = ref === "inherit" ? sessionModel : ref;
+    const check = checkThinking(model ? lookup(model) : undefined, level);
+    return check.warning ? [`${kindLabel(kind)}: ${check.warning}`] : [];
+  });
+}

package/src/pi/run-summary.ts

@@ -0,0 +1,172 @@
+/**
+ * One-line descriptions of subagent runs, shared by the transcript entries,
+ * `/bot-lobby runs`, the Master's reports and the zen feed row. Pure: every
+ * clock read arrives as `now`.
+ */
+import type { AgentRun } from "../schemas/findings.ts";
+import type { RunLogEntry } from "../schemas/task.ts";
+import { shortDuration } from "../text.ts";
+import { SLOT_LABELS, type SlotId } from "./mascot-art.ts";
+
+/** The zen column a run belongs to; a researcher reports under RESEARCH from any domain. */
+export function slotOf(run: Pick<AgentRun, "domain" | "role">): SlotId {
+  if (run.role === "researcher") return "research";
+  if (run.domain === "backend") return "dev";
+  return run.domain === "designer" ? "design" : "qa";
+}
+
+/** Upper-case agent name as the scene shows it (DEV, DESIGN, RESEARCH, QA). */
+export function agentName(run: Pick<AgentRun, "domain" | "role">): string {
+  return SLOT_LABELS[slotOf(run)];
+}
+
+/** Compact token count: 950, 41k, 1.2M. */
+export function tokens(count: number): string {
+  if (!Number.isFinite(count) || count < 1000) return String(Math.max(0, Math.round(count || 0)));
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  return `${(count / 1_000_000).toFixed(1)}M`;
+}
+
+function durationOf(run: Pick<AgentRun, "startedAt" | "finishedAt">, now: number): number {
+  const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
+  const elapsed = end - Date.parse(run.startedAt);
+  return Number.isFinite(elapsed) && elapsed > 0 ? elapsed : 0;
+}
+
+const STATUS_ICONS: Record<AgentRun["status"], string> = {
+  running: "◐",
+  success: "✓",
+  failed: "✗",
+  cancelled: "·",
+  timeout: "✗",
+};
+
+/** Why a run ended the way it did, in words, when that is not plain success. */
+export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "wrappedUp" | "attempts">): string[] {
+  const flags: string[] = [];
+  if (run.stalled) flags.push("stalled");
+  else if (run.status === "timeout") flags.push("hit its time limit");
+  else if (run.status === "failed") flags.push("failed");
+  else if (run.status === "cancelled") flags.push("cancelled");
+  if (run.wrappedUp) flags.push(run.status === "success" ? "wrapped up early — report may be partial" : "asked to wrap up");
+  if (run.attempts > 1) flags.push(`${run.attempts} attempts`);
+  return flags;
+}
+
+/**
+ * `✓ DEV worker · 3m 12s · 9 turns · 23 tools · 41k↑ 6k↓ · $0.12 · provider/model`,
+ * followed by any flags (stalled, time limit, wrapped up early, attempts).
+ */
+export function describeRun(run: AgentRun, now = Date.now()): string {
+  const parts = [`${STATUS_ICONS[run.status]} ${agentName(run)} ${run.role}`, shortDuration(durationOf(run, now))];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (run.tools) parts.push(`${run.tools} tool${run.tools === 1 ? "" : "s"}`);
+  if (run.usage && (run.usage.input || run.usage.output)) parts.push(`${tokens(run.usage.input)}↑ ${tokens(run.usage.output)}↓`);
+  if (run.usage?.cost) parts.push(`$${run.usage.cost.toFixed(2)}`);
+  if (run.model) parts.push(run.model);
+  parts.push(...runFlags(run));
+  const line = parts.join(" · ");
+  return run.status === "success" || !run.error ? line : `${line} — ${run.error.split("\n")[0]}`;
+}
+
+/** The persisted form of a finished run, for `task.runLog`. */
+export function runLogEntry(run: AgentRun): RunLogEntry {
+  return {
+    runId: run.runId,
+    domain: run.domain,
+    role: run.role,
+    status: run.status,
+    startedAt: run.startedAt,
+    ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+    ...(run.model ? { model: run.model } : {}),
+    ...(run.thinking ? { thinking: run.thinking } : {}),
+    ...(run.turns ?? run.usage?.turns ? { turns: run.turns ?? run.usage?.turns } : {}),
+    ...(run.tools ? { tools: run.tools } : {}),
+    ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
+    attempts: run.attempts,
+    ...(run.stalled ? { stalled: true } : {}),
+    ...(run.wrappedUp ? { wrappedUp: true } : {}),
+    ...(run.error ? { error: run.error.split("\n")[0]!.slice(0, 200) } : {}),
+  };
+}
+
+/** A persisted entry back as a run, so `describeRun` formats both the same way. */
+export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
+  return {
+    runId: entry.runId,
+    taskId,
+    domain: entry.domain,
+    role: entry.role,
+    status: entry.status,
+    output: "",
+    attempts: entry.attempts ?? 1,
+    startedAt: entry.startedAt,
+    ...(entry.finishedAt ? { finishedAt: entry.finishedAt } : {}),
+    ...(entry.model ? { model: entry.model } : {}),
+    ...(entry.thinking ? { thinking: entry.thinking } : {}),
+    ...(entry.turns ? { turns: entry.turns } : {}),
+    ...(entry.tools ? { tools: entry.tools } : {}),
+    ...(entry.input !== undefined ? { usage: { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0, turns: entry.turns ?? 0 } } : {}),
+    ...(entry.stalled ? { stalled: true } : {}),
+    ...(entry.wrappedUp ? { wrappedUp: true } : {}),
+    ...(entry.error ? { error: entry.error } : {}),
+  };
+}
+
+/** Silence after which a working agent reads as "quiet" in the scene. */
+export const QUIET_MS = 45_000;
+
+/** How long a running agent has produced nothing, or 0 when it is not running or has no clock yet. */
+export function quietFor(run: Pick<AgentRun, "status" | "lastEventAt" | "startedAt">, now: number): number {
+  if (run.status !== "running") return 0;
+  const last = run.lastEventAt ?? Date.parse(run.startedAt);
+  const quiet = now - last;
+  return Number.isFinite(quiet) && quiet > 0 ? quiet : 0;
+}
+
+export interface FeedLine {
+  text: string;
+  kind: "info" | "warning";
+}
+
+/** Ticks one working agent holds the feed before it rotates to the next (~3 s at the live clock). */
+export const FEED_ROTATE_TICKS = 12;
+
+/** What one working agent is doing right now, with a warning when something needs attention. */
+function liveFeed(run: AgentRun, now: number): FeedLine {
+  const name = agentName(run);
+  if (run.waitingFor) return { text: `⧗ ${name} waiting for ${run.waitingFor}${run.note ? ` · ${run.note}` : ""}`, kind: "warning" };
+  const quiet = quietFor(run, now);
+  if (quiet >= QUIET_MS) {
+    const doing = run.activity ? ` (last: ${run.activity}${run.detail ? ` ${run.detail}` : ""})` : "";
+    return { text: `! ${name} quiet for ${shortDuration(quiet)}${doing}`, kind: "warning" };
+  }
+  if (run.note && run.noteKind === "warning") return { text: `! ${name} ${run.note}`, kind: "warning" };
+  const parts = [`▸ ${name} ${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`turn ${turns}`);
+  if (run.tools) parts.push(`${run.tools} tools`);
+  if (run.usage && run.usage.input + run.usage.output > 0) parts.push(`${tokens(run.usage.input + run.usage.output)} tok`);
+  if (run.note) parts.push(run.note);
+  return { text: parts.join(" · "), kind: "info" };
+}
+
+/**
+ * The scene's feed row: a working agent that needs attention first, otherwise
+ * the working agents in rotation, otherwise the most recent finished run.
+ * Undefined before anything has run.
+ */
+export function feedLine(runs: readonly AgentRun[], now: number, tick: number): FeedLine | undefined {
+  const running = runs.filter((run) => run.status === "running");
+  if (running.length > 0) {
+    const lines = running.map((run) => liveFeed(run, now));
+    const warning = lines.find((line) => line.kind === "warning");
+    if (warning) return warning;
+    const index = Math.floor(Math.max(0, tick) / FEED_ROTATE_TICKS) % lines.length;
+    return lines[index];
+  }
+  const last = [...runs].filter((run) => run.finishedAt).sort((a, b) => Date.parse(a.finishedAt!) - Date.parse(b.finishedAt!)).at(-1);
+  if (!last) return undefined;
+  return { text: describeRun(last, now), kind: last.status === "success" && !last.wrappedUp ? "info" : "warning" };
+}