@a-t-h-i/bot-lobby 0.6.5 → 0.6.7

package/src/workflow/workflow.ts

@@ -49,6 +49,7 @@ import { assessReconnaissance, completionBlockers, decideReviewLoop, recordDecis
 import { detectSharedFiles, summarizeOutcomes } from "../master/synthesis.ts";
 import { tail, truncate } from "../text.ts";
 import { isAutoMode } from "../state/auto.ts";
+import { briefRejection } from "./brief.ts";
 import { assertNoPendingApprovals, pendingApprovals, requestApproval, resolveApproval } from "./approvals.ts";
 import { pingApproval } from "../pi/notify.ts";
 import { describeRun, runLogEntry } from "../pi/run-summary.ts";
@@ -295,7 +296,7 @@ async function handleClarify(task: Task, params: OrchestrateParams, deps: Workfl
   }
   const answer = params.options?.length ? await deps.choose(question, params.options) : await deps.ask(question);
   if (answer === undefined) {
-    return `No answer captured. Ask the user this in your reply, then continue.\n\nQuestion: ${question}`;
+    return `The user did not answer. Do not assume an answer or pick the recommended option: ask the user this again in your reply, end your turn, and continue only once they have answered.\n\nQuestion: ${question}`;
   }
   return `User answered: ${answer}`;
 }
@@ -680,6 +681,10 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
   };
 }
 
+const ANSWER_NOW = "Answer the questions now";
+/** Times an agent's abandoned questions are put to the user again before it decides. */
+const MAX_NUDGES = 5;
+
 /** Agents that may ask the user themselves: the designer, whose choices are the user's to see. */
 const ASKING_DOMAINS: ReadonlySet<Domain> = new Set(["designer"]);
 
@@ -705,7 +710,13 @@ function askRelay(task: Task, deps: WorkflowDeps, domain: Domain): { onAsk: Rela
       if (isAutoMode(deps.root, deps.configDir, task.id)) {
         return { answers: [], cancelled: true, globalNote: "Auto mode is on, so nobody can answer: decide with the options you recommend and say in your report what you chose and why." };
       }
-      const result = await askQuestions(questions, label, signal);
+      let result = await askQuestions(questions, label, signal);
+      // Leaving the questions must not quietly hand the choice to the agent: ask whether it may decide.
+      for (let nudges = 0; result.answers.length === 0 && result.cancelled && !signal.aborted && nudges < MAX_NUDGES; nudges++) {
+        const choice = await deps.choose(`${label} is waiting for your answer${questions.length === 1 ? "" : "s"} (${questions.map((question) => question.header).join(", ")}).`, [ANSWER_NOW, `Let ${label} decide with its recommendation`]);
+        if (choice !== ANSWER_NOW && choice !== undefined) break;
+        result = await askQuestions(questions, label, signal);
+      }
       recordDecision(task, askedDecision(label, questions, result), domain);
       return result;
     });
@@ -877,6 +888,8 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   }
   if (!starting) requireState(task, ["planning", "implementing", "reviewing"]);
   const assignments = parseAssignments(params);
+  const short = !deps.config.workflow.briefCheck ? [] : assignments.map((entry) => briefRejection(task.id, entry.domain, entry.instruction)).filter(Boolean);
+  if (short.length > 0) throw new Error(short.join("\n"));
   for (const { domain } of assignments) assertNoPendingApprovals(task, domain);
   for (const { domain } of assignments) if (!task.domains.includes(domain)) task.domains.push(domain);
   // Under a time budget every step is given its share before any starts; a spent budget starts none.

package/src/pi/expressions.ts

@@ -1,169 +0,0 @@
-/**
- * Caller-driven expression schedule for the zen sprites.
- *
- * Pure and deterministic: `now` and the random source are always injected, so
- * the art, layout and metrics stay free of `Date.now`/`Math.random`. Each slot
- * and the oracle keeps its own state, holds its rest frame between events and,
- * after a random 20-30 s gap, plays a short blink or a longer emote.
- */
-
-/** Resting gap before the next expression, milliseconds. */
-export const BLINK_MIN_MS = 20_000;
-export const BLINK_MAX_MS = 30_000;
-/** How long one blink and one emote are held. */
-export const BLINK_MS = 500;
-export const EMOTE_MS = 2000;
-/** Fast clock while an expression plays, short enough that a blink is never skipped. */
-export const FAST_TICK_MS = 120;
-
-/** Art frame indexes: 0 rests, 1 blinks, `2 ..` are emotes. */
-export const REST_FRAME = 0;
-export const BLINK_FRAME = 1;
-export const EMOTE_FRAME = 2;
-/**
- * Emote frame range: `EMOTE_FRAME .. EMOTE_FRAME + EMOTE_FRAMES - 1`; an emote
- * steps through them: the open face, a blink, then its action (see kaomoji.ts).
- */
-export const EMOTE_FRAMES = 4;
-/** Each emote frame is held this long, so an emote steps through its frames. */
-export const EMOTE_STEP_MS = Math.floor(EMOTE_MS / EMOTE_FRAMES);
-
-const BLINK_CHANCE = 0.65;
-/** Working agents emote as often as they blink. */
-export const WORKING_BLINK_CHANCE = 0.5;
-/** Upper bound (exclusive) of an expression's variant. */
-const VARIANT_SPAN = 2 ** 30;
-
-export interface ExpressionState {
-  /** Earliest `now` the next expression may start. */
-  nextAt: number;
-  /** When the playing expression ends; not after `now` while resting. */
-  until: number;
-  /** When the current expression started; drives emote frame stepping. */
-  startedAt: number;
-  /** Frame index for the art: 0 rest, 1 blink, 2+ emote. */
-  frame: number;
-  /** Drawn once per expression; picks which face an emote shows (see kaomoji.ts). */
-  variant: number;
-}
-
-/** A random draw clamped to `[0, 1]`, so a non-finite source value can never leak. */
-function unit(rng: () => number): number {
-  const value = rng();
-  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
-}
-
-/** Resting window between expressions, milliseconds. */
-export interface ExpressionGap {
-  min: number;
-  max: number;
-}
-
-/** Idle agent slots rest 20-30 s between expressions. */
-export const SLOT_GAP: ExpressionGap = { min: BLINK_MIN_MS, max: BLINK_MAX_MS };
-/** Working agents are livelier: 8-15 s between expressions. */
-export const WORKING_GAP: ExpressionGap = { min: 8_000, max: 15_000 };
-/** The oracle is the scene's centrepiece: it blinks and emotes every 6-12 s. */
-export const ORACLE_GAP: ExpressionGap = { min: 6_000, max: 12_000 };
-
-/** Random resting gap before the next expression, inside `gap` (the slot window by default). */
-export function nextGap(rng: () => number, gap: ExpressionGap = SLOT_GAP): number {
-  return gap.min + Math.round(unit(rng) * (gap.max - gap.min));
-}
-
-/** Whether the next expression blinks (~65% by default) or emotes. */
-export function pickEvent(rng: () => number, blinkChance = BLINK_CHANCE): "blink" | "emote" {
-  return unit(rng) < blinkChance ? "blink" : "emote";
-}
-
-function drawVariant(rng: () => number): number {
-  return Math.floor(unit(rng) * (VARIANT_SPAN - 1));
-}
-
-/** A freshly rested expression that fires for the first time after one random gap. */
-export function createExpression(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
-  const start = Number.isFinite(now) ? now : 0;
-  return { nextAt: start + nextGap(rng, gap), until: start, startedAt: start, frame: REST_FRAME, variant: 0 };
-}
-
-/** True while `now` is inside a playing blink or emote. */
-export function isPlaying(state: ExpressionState, now: number): boolean {
-  return Number.isFinite(now) && now < state.until;
-}
-
-/** True when any state is mid-expression; the caller uses it to retime its clock. */
-export function anyPlaying(states: readonly ExpressionState[], now: number): boolean {
-  return states.some((state) => isPlaying(state, now));
-}
-
-/**
- * Advance one sprite to `now`: start a blink or emote once the gap has elapsed,
- * drop back to the rest frame when it ends, and change nothing in between.
- */
-export function advanceExpression(
-  state: ExpressionState,
-  now: number,
-  rng: () => number,
-  gap: ExpressionGap = SLOT_GAP,
-  blinkChance = BLINK_CHANCE,
-): ExpressionState {
-  if (!Number.isFinite(now)) return state;
-  if (now < state.until) return state.frame >= EMOTE_FRAME ? steppedEmote(state, now) : state;
-  if (now < state.nextAt) return state.frame === REST_FRAME ? state : { ...state, frame: REST_FRAME };
-  return play(now, rng, gap, blinkChance);
-}
-
-function play(now: number, rng: () => number, gap: ExpressionGap, blinkChance: number): ExpressionState {
-  const blink = pickEvent(rng, blinkChance) === "blink";
-  return blink ? startBlink(now, rng, gap) : triggerEmote(now, rng, gap);
-}
-
-function startBlink(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
-  const until = now + BLINK_MS;
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: BLINK_FRAME, variant: drawVariant(rng) };
-}
-
-/**
- * Start an emote right now, whatever the sprite was doing: the reaction when a
- * slot's situation changes (it starts, finishes, fails, stalls, waits or
- * receives a file). The next scheduled expression follows one gap later.
- */
-export function triggerEmote(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
-  const start = Number.isFinite(now) ? now : 0;
-  const until = start + EMOTE_MS;
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: start, frame: EMOTE_FRAME, variant: drawVariant(rng) };
-}
-
-/** One sub-step of a playing expression; the oracle's blink and glance step through these. */
-export const PHASE_MS = FAST_TICK_MS;
-
-/** Sub-steps elapsed in the playing expression, 0 while resting or on a bad clock. */
-export function expressionPhase(state: ExpressionState, now: number): number {
-  if (!isPlaying(state, now)) return 0;
-  const elapsed = now - state.startedAt;
-  return Number.isFinite(elapsed) && elapsed > 0 ? Math.floor(elapsed / PHASE_MS) : 0;
-}
-
-/** How long the oracle lip-syncs after it says something new, and one mouth shape's hold. */
-export const TALK_MS = 1800;
-export const TALK_STEP_MS = FAST_TICK_MS;
-
-/** Mouth-shape index while the oracle is still talking about what it said at `since`, else undefined. */
-export function talkFrame(since: number | undefined, now: number): number | undefined {
-  if (since === undefined || !Number.isFinite(since) || !Number.isFinite(now)) return undefined;
-  const elapsed = now - since;
-  return elapsed >= 0 && elapsed < TALK_MS ? Math.floor(elapsed / TALK_STEP_MS) : undefined;
-}
-
-/** Emote frame for `now`: one step per EMOTE_STEP_MS, clamped to the last frame. */
-function emoteFrameAt(startedAt: number, now: number): number {
-  const elapsed = now - startedAt;
-  const step = Number.isFinite(elapsed) && elapsed > 0 ? Math.floor(elapsed / EMOTE_STEP_MS) : 0;
-  return EMOTE_FRAME + Math.min(EMOTE_FRAMES - 1, Math.max(0, step));
-}
-
-/** Advance an in-flight emote's frame, keeping the same object when it has not changed. */
-function steppedEmote(state: ExpressionState, now: number): ExpressionState {
-  const frame = emoteFrameAt(state.startedAt, now);
-  return frame === state.frame ? state : { ...state, frame };
-}

package/src/pi/kaomoji.ts

@@ -1,227 +0,0 @@
-/**
- * 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));
-}