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

package/src/master/research.ts

@@ -1,13 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
-import type { BotLobbyConfig } from "../schemas/configuration.ts";
+import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, ResearchResult } from "../schemas/findings.ts";
-import { runAgent, type AgentRequest } from "../execution/agent-runner.ts";
+import { runAgent, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
 import { writeFileEnsured } from "../knowledge/store.ts";
 import { isResearchResultUsable, parseResearchResult, validateResearchResult } from "../roles/researcher.ts";
-import { resolveModel } from "./master.ts";
 
 export interface ResearchOutcome {
   result: ResearchResult;
@@ -25,6 +24,7 @@ export interface ResearchRequest {
   cwd: string;
   taskDir: string;
   config: BotLobbyConfig;
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
 }
@@ -75,6 +75,7 @@ function toOutcome(run: AgentRun, domain: Domain): ResearchOutcome {
 
 /** Run the researcher for one domain and persist its report for audit. */
 export async function runResearch(request: ResearchRequest, run: ProcessRunner = spawnPiProcess): Promise<ResearchOutcome> {
+  const profile = profileFor(request.config, request.profile, request.domain, "researcher");
   const agentRun = await runAgent(
     {
       taskId: request.taskId,
@@ -82,13 +83,13 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       role: "researcher",
       instruction: request.instruction,
       context: researchContext(request),
-      model: resolveModel(request.config, request.domain),
-      thinking: request.config.agents[request.domain].thinking,
-      timeoutMs: request.config.workflow.agentTimeoutMs,
+      model: profile.model,
+      thinking: profile.thinking,
+      timeoutMs: profile.timeoutMs,
       cwd: request.cwd,
       signal: request.signal,
       onUpdate: request.onUpdate,
-      retries: request.config.workflow.maxAgentRetries,
+      ...watchdogOptions(request.config.workflow),
     },
     run,
   );

package/src/pi/activity.ts

@@ -61,3 +61,48 @@ export function oracleActivityWord(toolName: string, args?: unknown): string {
   const action = orchestrateAction(args);
   return (action && ORACLE_ACTION_WORDS[action]) || FALLBACK_WORD;
 }
+
+const DETAIL_CHARS = 28;
+
+function clip(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > DETAIL_CHARS ? `${flat.slice(0, DETAIL_CHARS - 1)}…` : flat;
+}
+
+function field(args: unknown, ...names: string[]): string | undefined {
+  if (!args || typeof args !== "object") return undefined;
+  for (const name of names) {
+    const value = (args as Record<string, unknown>)[name];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return undefined;
+}
+
+/** Last path segment, so `src/pi/zen.ts` reads `zen.ts`. */
+function baseName(path: string): string {
+  const parts = path.replace(/[\\/]+$/, "").split(/[\\/]/);
+  return parts.at(-1) || path;
+}
+
+/**
+ * A short target for what a tool call touches: the file for read/edit/write,
+ * the command head for bash, the pattern for grep, the query for web search.
+ * Pure; undefined when the arguments name nothing useful.
+ */
+export function activityDetail(toolName: string, args?: unknown): string | undefined {
+  const tool = toolName.trim().toLowerCase();
+  if (tool === "read" || tool === "edit" || tool === "write" || tool === "ls") {
+    const path = field(args, "path", "file_path", "file");
+    return path ? clip(baseName(path)) : undefined;
+  }
+  if (tool === "bash") {
+    const command = field(args, "command", "cmd");
+    return command ? clip(command) : undefined;
+  }
+  if (tool === "grep" || tool === "find") {
+    const pattern = field(args, "pattern", "query", "glob");
+    return pattern ? clip(`"${pattern}"`) : undefined;
+  }
+  const query = field(args, "query", "url", "path");
+  return query ? clip(query) : undefined;
+}

package/src/pi/commands.ts

@@ -2,7 +2,8 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, createTask, taskRequest, type Task } from "../schemas/task.ts";
-import { detectProjectRoot, globalConfigPath, loadConfig, readDataRoots } from "../state/project.ts";
+import { detectProjectRoot, globalConfigPath, loadConfig, readDataRoots, readRawConfig } from "../state/project.ts";
+import { hasScoutThinking, SCOUT_THINKING } from "../schemas/configuration.ts";
 import {
   activeTask,
   claimTask,
@@ -24,6 +25,9 @@ import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type App
 import { shortTitle } from "../text.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
 import { applyMasterModel, openSettings } from "./settings-ui.ts";
+import { modelRef, thinkingMismatches } from "./model-support.ts";
+import { describeRun, runFromLog } from "./run-summary.ts";
+import { modelLookup } from "./tools.ts";
 
 const HELP = [
   "/bot-lobby <request>        Start a task through the workflow",
@@ -33,6 +37,7 @@ const HELP = [
   "/bot-lobby cancel [taskId]  Abandon a task",
   "/bot-lobby approve|amend <text>|decline   Answer the current proposal",
   "/bot-lobby knowledge        Show persistent knowledge files",
+  "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
   "/bot-lobby settings         Edit per-agent model/thinking/instructions",
   "/bot-lobby config           Show effective configuration",
   "/bot-lobby minimize|restore   Hide or restore bot-lobby for this session (ctrl+shift+m)",
@@ -40,7 +45,7 @@ const HELP = [
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["status", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim"]);
+const SUBCOMMANDS = new Set(["status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim"]);
 
 function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
@@ -118,6 +123,20 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
   ctx.ui.notify(task ? `${describeTask(task)}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
+/** Recent runs of the active (or named) task, newest last, so slow models are easy to spot. */
+export function runsReport(task: Task | undefined, limit = 20): string {
+  if (!task) return "No bot-lobby task found.";
+  const entries = (task.runLog ?? []).slice(-limit);
+  if (entries.length === 0) return `${task.id}: no finished subagent runs yet.`;
+  return [`${task.id} — last ${entries.length} run${entries.length === 1 ? "" : "s"}:`, ...entries.map((entry) => describeRun(runFromLog(entry, task.id)))].join("\n");
+}
+
+function showRuns(ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = selectTask(root, configDir, taskId, ctx.sessionManager.getSessionId()) ?? (taskId ? undefined : ownerlessTask(root, configDir));
+  ctx.ui.notify(runsReport(task), task ? "info" : "warning");
+}
+
 function showTasks(ctx: ExtensionCommandContext, configDir: string): void {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const { tasks, corrupted } = taskHealth(root, configDir);
@@ -208,7 +227,11 @@ function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
 }
 
 function showConfig(ctx: ExtensionCommandContext): void {
-  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(loadConfig(), null, 2)}`, "info");
+  const config = loadConfig();
+  const warnings = thinkingMismatches(config, modelLookup(ctx), ctx.model ? modelRef(ctx.model) : undefined);
+  if (hasScoutThinking(readRawConfig())) warnings.push(`Scout: thinking is fixed at "${SCOUT_THINKING}"; the scout.thinking value in the file is ignored.`);
+  const notes = warnings.length > 0 ? `\n\nWarnings:\n${warnings.map((line) => `- ${line}`).join("\n")}` : "";
+  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
 }
 
 export function registerCommands(pi: ExtensionAPI, configDir: string): void {
@@ -231,6 +254,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return showStatus(ctx, configDir, rest[0]);
         case "tasks":
           return showTasks(ctx, configDir);
+        case "runs":
+          return showRuns(ctx, configDir, rest[0]);
         case "pause":
           return setPaused(ctx, configDir, true, rest[0]);
         case "resume":

package/src/pi/expressions.ts

@@ -20,12 +20,19 @@ export const FAST_TICK_MS = 120;
 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. */
-export const EMOTE_FRAMES = 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. */
@@ -36,6 +43,8 @@ export interface ExpressionState {
   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. */
@@ -50,8 +59,10 @@ export interface ExpressionGap {
   max: number;
 }
 
-/** Agent slots rest 20-30 s between expressions. */
+/** 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 };
 
@@ -60,15 +71,19 @@ export function nextGap(rng: () => number, gap: ExpressionGap = SLOT_GAP): numbe
   return gap.min + Math.round(unit(rng) * (gap.max - gap.min));
 }
 
-/** Whether the next expression blinks (~65%) or emotes (~35%). */
-export function pickEvent(rng: () => number): "blink" | "emote" {
-  return unit(rng) < BLINK_CHANCE ? "blink" : "emote";
+/** 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 };
+  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. */
@@ -90,17 +105,33 @@ export function advanceExpression(
   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);
+  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 play(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
-  const blink = pickEvent(rng) === "blink";
-  const until = now + (blink ? BLINK_MS : EMOTE_MS);
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: blink ? BLINK_FRAME : EMOTE_FRAME };
+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. */

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"),