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

package/src/pi/settings-ui.ts

@@ -6,47 +6,71 @@ import {
   type Theme,
 } from "@earendil-works/pi-coding-agent";
 import { Container, type Component, type Focusable, fuzzyFilter, getKeybindings, Input, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
-import { AGENT_KINDS, type AgentKind } from "../schemas/agent.ts";
 import {
   INHERIT_MODEL,
-  INHERIT_THINKING,
   isThinkingLevel,
-  THINKING_LEVELS,
+  SCOUT_THINKING,
+  SUBAGENT_KINDS,
   type AgentModelConfig,
   type BotLobbyConfig,
+  type SubagentKind,
 } from "../schemas/configuration.ts";
 import { globalConfigPath, loadConfig, saveConfig } from "../state/project.ts";
+import { checkThinking, kindLabel, modelRef, supportedThinking } from "./model-support.ts";
+import { modelLookup } from "./tools.ts";
 
 const CUSTOM_MODEL = "__custom__";
 const MAX_VISIBLE = 12;
 
-function agentLabel(agent: AgentKind): string {
-  return agent === "master" ? "Master" : `${agent[0]!.toUpperCase()}${agent.slice(1)}`;
+/** One settings entry: the master or a subagent profile. */
+export type SettingsKind = "master" | SubagentKind;
+export const SETTINGS_KINDS: readonly SettingsKind[] = ["master", ...SUBAGENT_KINDS];
+
+/** The editable fields of one entry; scouts have no thinking and no instructions of their own. */
+interface EntryView {
+  model: string;
+  thinking?: string;
+  instructions?: string;
+  timeoutMs?: number;
+}
+
+function entryView(config: BotLobbyConfig, kind: SettingsKind): EntryView {
+  if (kind === "master") return config.master;
+  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs };
+  if (kind === "researcher") return config.researcher;
+  return config.agents[kind];
 }
 
-function agentConfig(config: BotLobbyConfig, agent: AgentKind): AgentModelConfig {
-  return agent === "master" ? config.master : config.agents[agent];
+interface EntryPatch {
+  model?: string;
+  thinking?: string;
+  instructions?: string;
+  timeoutMs?: number;
 }
 
-function updateAgent(agent: AgentKind, patch: Partial<AgentModelConfig>): void {
-  const config = loadConfig();
-  if (agent === "master") config.master = { ...config.master, ...patch };
-  else config.agents[agent] = { ...config.agents[agent], ...patch };
-  saveConfig(config);
+/** Apply a patch to one entry in a config copy; scouts ignore thinking and instructions. */
+export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: EntryPatch): BotLobbyConfig {
+  const next: BotLobbyConfig = { ...config, agents: { ...config.agents } };
+  if (kind === "master") next.master = { ...config.master, ...patch } as AgentModelConfig;
+  else if (kind === "scout") {
+    next.scout = {
+      model: patch.model ?? config.scout.model,
+      timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs,
+    };
+  } else if (kind === "researcher") next.researcher = { ...config.researcher, ...patch } as AgentModelConfig;
+  else next.agents[kind] = { ...config.agents[kind], ...patch } as AgentModelConfig;
+  return next;
 }
 
-/** Find a `provider/id` (or bare id) among the models this session can use. */
-function findModel(ctx: ExtensionContext, ref: string) {
-  const slash = ref.indexOf("/");
-  if (slash > 0) return ctx.modelRegistry.find(ref.slice(0, slash), ref.slice(slash + 1));
-  return ctx.modelRegistry.getAvailable().find((model) => model.id === ref);
+function updateEntry(kind: SettingsKind, patch: EntryPatch): void {
+  saveConfig(patchEntry(loadConfig(), kind, patch));
 }
 
 /** Apply the master model/thinking to the live session; "inherit" leaves it alone. */
 export async function applyMasterModel(pi: ExtensionAPI, ctx: ExtensionContext, config: BotLobbyConfig): Promise<void> {
   const { model, thinking } = config.master;
   if (model !== INHERIT_MODEL) {
-    const found = findModel(ctx, model);
+    const found = modelLookup(ctx)(model);
     if (!found) ctx.ui.notify(`bot-lobby: unknown master model "${model}".`, "warning");
     else if (!(await pi.setModel(found))) ctx.ui.notify(`bot-lobby: no auth for ${model}.`, "warning");
   }
@@ -173,9 +197,13 @@ async function pick(ctx: ExtensionContext, title: string, items: SelectItem[], o
   return options.search ? pickSearch(ctx, title, items) : pickPlain(ctx, title, items);
 }
 
-export function modelItems(ctx: ExtensionContext, current: string): SelectItem[] {
-  const inherit = current === INHERIT_MODEL ? `${INHERIT_MODEL} ✓` : INHERIT_MODEL;
-  const items: SelectItem[] = [{ value: INHERIT_MODEL, label: inherit, description: "Use the session's current model" }];
+/** Model choices; only the master offers `inherit`, since it is the live session itself. */
+export function modelItems(ctx: ExtensionContext, current: string, includeInherit = true): SelectItem[] {
+  const items: SelectItem[] = [];
+  if (includeInherit) {
+    const inherit = current === INHERIT_MODEL ? `${INHERIT_MODEL} ✓` : INHERIT_MODEL;
+    items.push({ value: INHERIT_MODEL, label: inherit, description: "Use the session's current model" });
+  }
   const usable = ctx.scopedModels.length > 0 ? ctx.scopedModels.map((entry) => entry.model) : ctx.modelRegistry.getAvailable();
   for (const model of usable) {
     const value = `${model.provider}/${model.id}`;
@@ -187,54 +215,123 @@ export function modelItems(ctx: ExtensionContext, current: string): SelectItem[]
   return items;
 }
 
-async function commit(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind, patch: Partial<AgentModelConfig>, detail: string): Promise<void> {
-  updateAgent(agent, patch);
-  if (agent === "master") await applyMasterModel(pi, ctx, loadConfig());
-  ctx.ui.notify(`bot-lobby: ${agent} ${detail} — saved to ${globalConfigPath()}`, "info");
+/** The model an entry runs on: its own, or the session's while unset. */
+function effectiveModel(ctx: ExtensionContext, model: string) {
+  if (model !== INHERIT_MODEL) return modelLookup(ctx)(model);
+  return ctx.model;
+}
+
+/** Thinking choices limited to what the entry's model supports. */
+export function thinkingItems(levels: readonly string[], current: string | undefined): SelectItem[] {
+  return levels.map((level) => (level === current ? { value: level, label: `${level} ✓` } : { value: level, label: level }));
 }
 
-async function editModel(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).model;
-  const choice = await pick(ctx, `Model — ${agentLabel(agent)}`, modelItems(ctx, current), { search: true });
+async function commit(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind, patch: EntryPatch, detail: string): Promise<void> {
+  updateEntry(kind, patch);
+  if (kind === "master") await applyMasterModel(pi, ctx, loadConfig());
+  ctx.ui.notify(`bot-lobby: ${kindLabel(kind)} ${detail} — saved to ${globalConfigPath()}`, "info");
+}
+
+/** After a model change, clamp a saved thinking level the new model cannot run, and say so. */
+async function reconcileThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  if (!view.thinking) return;
+  const check = checkThinking(effectiveModel(ctx, view.model), view.thinking);
+  if (!check.warning) return;
+  updateEntry(kind, { thinking: check.level });
+  if (kind === "master") await applyMasterModel(pi, ctx, loadConfig());
+  ctx.ui.notify(`bot-lobby: ${kindLabel(kind)} — ${check.warning}.`, "warning");
+}
+
+async function editModel(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).model;
+  const choice = await pick(ctx, `Model — ${kindLabel(kind)}`, modelItems(ctx, current, kind === "master"), { search: true });
   if (choice === undefined) return;
   const typed = choice === CUSTOM_MODEL ? (await ctx.ui.input("Model id", "provider/model"))?.trim() : choice;
   if (!typed) return;
-  await commit(pi, ctx, agent, { model: typed }, `model → ${typed}`);
+  await commit(pi, ctx, kind, { model: typed }, `model → ${typed}`);
+  await reconcileThinking(pi, ctx, kind);
 }
 
-async function editThinking(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).thinking;
-  const items: SelectItem[] = [
-    { value: INHERIT_THINKING, label: `${INHERIT_THINKING} (live session level)`, description: "Use the thinking level of the current session" },
-    ...THINKING_LEVELS.map((level) => ({ value: level, label: level })),
-  ].map((item) => (item.value === current ? { ...item, label: `${item.label} ✓` } : item));
-  const level = await pick(ctx, `Thinking — ${agentLabel(agent)}`, items);
-  if (!level) return;
-  await commit(pi, ctx, agent, { thinking: level }, `thinking → ${level}`);
+async function editThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  const model = effectiveModel(ctx, view.model);
+  const levels = supportedThinking(model);
+  const title = model ? `Thinking — ${kindLabel(kind)} (${modelRef(model)})` : `Thinking — ${kindLabel(kind)}`;
+  const level = await pick(ctx, title, thinkingItems(levels, view.thinking));
+  if (!level || !isThinkingLevel(level)) return;
+  await commit(pi, ctx, kind, { thinking: level }, `thinking → ${level}`);
+}
+
+async function editTimeout(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).timeoutMs ?? loadConfig().workflow.agentTimeoutMs;
+  const typed = (await ctx.ui.input(`Time limit (minutes) — ${kindLabel(kind)}`, String(Math.round(current / 60_000))))?.trim();
+  if (!typed) return;
+  const minutes = Number(typed);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    ctx.ui.notify(`bot-lobby: "${typed}" is not a positive number of minutes.`, "warning");
+    return;
+  }
+  await commit(pi, ctx, kind, { timeoutMs: Math.round(minutes * 60_000) }, `time limit → ${minutes}m`);
 }
 
-async function editInstructions(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).instructions ?? "";
-  const text = await ctx.ui.editor(`Instructions — ${agentLabel(agent)}`, current);
+async function editInstructions(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).instructions ?? "";
+  const text = await ctx.ui.editor(`Instructions — ${kindLabel(kind)}`, current);
   if (text === undefined) return;
-  await commit(pi, ctx, agent, { instructions: text.trim() }, "instructions saved");
+  await commit(pi, ctx, kind, { instructions: text.trim() }, "instructions saved");
+}
+
+function minutes(ms: number | undefined): string {
+  return ms ? `${Math.round(ms / 60_000)}m` : "default";
+}
+
+/** Menu rows for one entry; scouts expose model and time limit only (their thinking is fixed). */
+export function entryItems(kind: SettingsKind, view: EntryView): SelectItem[] {
+  const items: SelectItem[] = [{ value: "model", label: "Model", description: view.model }];
+  if (kind === "scout") items.push({ value: "fixed", label: "Thinking", description: `${SCOUT_THINKING} (fixed for scouts)` });
+  else items.push({ value: "thinking", label: "Thinking", description: view.thinking ?? "" });
+  if (kind !== "master") items.push({ value: "timeout", label: "Time limit", description: minutes(view.timeoutMs) });
+  if (kind !== "scout" && kind !== "researcher") {
+    items.push({ value: "instructions", label: "Instructions", description: view.instructions ? `${view.instructions.length} chars` : "(none)" });
+  }
+  items.push({ value: "back", label: "Back" });
+  return items;
 }
 
-async function editAgent(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
+async function editEntry(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
   for (;;) {
-    const cfg = agentConfig(loadConfig(), agent);
-    const items: SelectItem[] = [
-      { value: "model", label: "Model", description: cfg.model },
-      { value: "thinking", label: "Thinking", description: cfg.thinking },
-      { value: "instructions", label: "Instructions", description: cfg.instructions ? `${cfg.instructions.length} chars` : "(none)" },
-      { value: "back", label: "Back" },
-    ];
-    const action = await pick(ctx, `${agentLabel(agent)} settings`, items);
+    const action = await pick(ctx, `${kindLabel(kind)} settings`, entryItems(kind, entryView(loadConfig(), kind)));
     if (!action || action === "back") return;
-    if (action === "model") await editModel(pi, ctx, agent);
-    else if (action === "thinking") await editThinking(pi, ctx, agent);
-    else await editInstructions(pi, ctx, agent);
+    if (action === "model") await editModel(pi, ctx, kind);
+    else if (action === "thinking") await editThinking(pi, ctx, kind);
+    else if (action === "timeout") await editTimeout(pi, ctx, kind);
+    else if (action === "instructions") await editInstructions(pi, ctx, kind);
+  }
+}
+
+/**
+ * Subagents never inherit silently: any subagent whose model is still unset is
+ * pinned to the session's current model and saved, so settings always show
+ * what each agent runs on.
+ */
+export function prefillModels(config: BotLobbyConfig, sessionModel: string | undefined): { config: BotLobbyConfig; filled: SubagentKind[] } {
+  if (!sessionModel) return { config, filled: [] };
+  let next = config;
+  const filled: SubagentKind[] = [];
+  for (const kind of SUBAGENT_KINDS) {
+    if (entryView(next, kind).model !== INHERIT_MODEL) continue;
+    next = patchEntry(next, kind, { model: sessionModel });
+    filled.push(kind);
   }
+  return { config: next, filled };
+}
+
+function entryDescription(kind: SettingsKind, view: EntryView): string {
+  const thinking = kind === "scout" ? SCOUT_THINKING : view.thinking;
+  const custom = view.instructions ? " · custom" : "";
+  const limit = kind === "master" ? "" : ` · ${minutes(view.timeoutMs)}`;
+  return `${view.model} · ${thinking}${limit}${custom}`;
 }
 
 /** Open the per-agent settings editor; every change is written to the global config. */
@@ -243,16 +340,17 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
     ctx.ui.notify(`bot-lobby settings live in ${globalConfigPath()}; edit that file outside the TUI.`, "info");
     return;
   }
+  const prefilled = prefillModels(loadConfig(), ctx.model ? modelRef(ctx.model) : undefined);
+  if (prefilled.filled.length > 0) {
+    saveConfig(prefilled.config);
+    ctx.ui.notify(`bot-lobby: set ${prefilled.filled.map(kindLabel).join(", ")} to the session model; change them here any time.`, "info");
+  }
   for (;;) {
     const config = loadConfig();
-    const items: SelectItem[] = AGENT_KINDS.map((agent) => {
-      const cfg = agentConfig(config, agent);
-      const custom = cfg.instructions ? " · custom" : "";
-      return { value: agent, label: agentLabel(agent), description: `${cfg.model} · ${cfg.thinking}${custom}` };
-    });
+    const items: SelectItem[] = SETTINGS_KINDS.map((kind) => ({ value: kind, label: kindLabel(kind), description: entryDescription(kind, entryView(config, kind)) }));
     items.push({ value: "close", label: "Close" });
     const choice = await pick(ctx, "bot-lobby settings", items);
     if (!choice || choice === "close") return;
-    await editAgent(pi, ctx, choice as AgentKind);
+    await editEntry(pi, ctx, choice as SettingsKind);
   }
 }

package/src/pi/tools.ts

@@ -4,11 +4,12 @@ import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
-import { inheritThinking } from "../schemas/configuration.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { isQuiet } from "./quiet.ts";
+import { createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
+import { agentName, describeRun } from "./run-summary.ts";
 import {
   ORCHESTRATE_ACTIONS,
   runWorkflowAction,
@@ -29,6 +30,15 @@ const OrchestrateSchema = Type.Object({
   plan: Type.Optional(Type.String({ description: "plan: the detailed internal plan" })),
   domain: Type.Optional(Type.String({ description: "implement/research: designer, backend, or qa" })),
   task: Type.Optional(Type.String({ description: "implement: the concrete step for that domain's worker" })),
+  assignments: Type.Optional(
+    Type.Array(
+      Type.Object({
+        domain: Type.String({ description: "designer, backend, or qa" }),
+        task: Type.String({ description: "the concrete step(s) for that domain's worker" }),
+      }),
+      { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
+    ),
+  ),
   approvalId: Type.Optional(Type.String({ description: "resolve_approval: the approval id from a worker result" })),
   decision: Type.Optional(
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
@@ -49,7 +59,7 @@ const DESCRIPTION = [
   "Actions: clarify (ask the user), scout (domain reconnaissance in parallel), research (summon the",
   "read-only researcher for cited internet evidence on a complex change, tool, plugin, doc set or",
   "dependency), propose (record the proposal and request approval), plan (record the internal",
-  "plan), implement (delegate one step to a domain worker), qa (final quality gate and the only",
+  "plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "review), knowledge (record approved knowledge or a decision),",
   "compact (replace a knowledge file with a rewritten version, archiving the old one),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
@@ -57,22 +67,39 @@ const DESCRIPTION = [
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
-/** Build the engine dependencies from the current Pi context. `thinking` is the live session level used by agents configured to inherit it. */
+/** Resolve a `provider/id` (or bare id) against the models this session knows. */
+export function modelLookup(ctx: ExtensionContext): ModelLookup {
+  return (ref) => {
+    const slash = ref.indexOf("/");
+    if (slash > 0) return ctx.modelRegistry.find(ref.slice(0, slash), ref.slice(slash + 1));
+    return ctx.modelRegistry.getAvailable().find((model) => model.id === ref);
+  };
+}
+
+/** Build the engine dependencies from the current Pi context; every agent's model and thinking come from settings. */
 export function workflowDeps(
   ctx: ExtensionContext,
   configDir: string,
   signal: AbortSignal | undefined,
   onUpdate: ((run: AgentRun) => void) | undefined,
   runProcess?: ProcessRunner,
-  thinking?: string,
 ): WorkflowDeps {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const hasUI = ctx.hasUI;
+  const config = loadConfig();
+  const warn = (message: string) => {
+    if (hasUI) ctx.ui.notify(message, "warning");
+  };
   return {
     root,
     configDir,
     cwd: ctx.cwd,
-    config: inheritThinking(loadConfig(), thinking),
+    config,
+    profile: createProfileResolver(config, {
+      lookup: modelLookup(ctx),
+      sessionModel: ctx.model ? modelRef(ctx.model) : undefined,
+      warn,
+    }),
     sessionId: ctx.sessionManager.getSessionId(),
     signal,
     onUpdate,
@@ -106,13 +133,28 @@ function runReporter(
 /** TUI-only transcript entries; these never enter the model's context. */
 function registerBotLobbyEntries(pi: ExtensionAPI): void {
   pi.registerEntryRenderer("bot-lobby", (entry, { expanded }, theme) => {
-    const data = entry.data as { kind?: string; taskId?: string; text?: string } | undefined;
+    const data = entry.data as { kind?: string; taskId?: string; text?: string; ok?: boolean } | undefined;
+    if (data?.kind === "run") {
+      // One compact line per finished subagent run.
+      return new Text(theme.fg(data.ok ? "dim" : "warning", data.text ?? ""), 0, 0);
+    }
     const header = `bot-lobby ${data?.taskId ?? ""} — ${data?.kind ?? "note"}`.trim();
     const body = data?.text ?? "";
     return new Text(`${theme.fg("accent", theme.bold(header))}\n${theme.fg("toolOutput", expanded ? body : truncate(body, 600))}`, 0, 0);
   });
 }
 
+/** A transcript line per finished run, plus a warning for anything that stalled or ran out of time. */
+function reportFinishedRuns(pi: ExtensionAPI, ctx: ExtensionContext, result: WorkflowResult): void {
+  for (const run of result.runs ?? []) {
+    const ok = run.status === "success" && !run.wrappedUp;
+    pi.appendEntry("bot-lobby", { kind: "run", taskId: result.taskId, text: describeRun(run), ok });
+    if (!ctx.hasUI) continue;
+    if (run.stalled) ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} stalled — ${run.error ?? "no output"}`, "warning");
+    else if (run.status === "timeout") ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} ${run.error ?? "hit its time limit"}`, "warning");
+  }
+}
+
 export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, runProcess?: ProcessRunner): void {
   registerBotLobbyEntries(pi);
   pi.registerTool({
@@ -128,11 +170,12 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
     renderShell: "self",
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const root = detectProjectRoot(ctx.cwd, configDir);
-      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess, pi.getThinkingLevel());
+      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess);
       const result = await runWorkflowAction(params as OrchestrateParams, deps);
       if (params.action === "propose" && params.proposal && result.ok) {
         pi.appendEntry("bot-lobby", { kind: "proposal", taskId: params.taskId, text: params.proposal });
       }
+      reportFinishedRuns(pi, ctx, result);
       applyStatus(ctx, root, configDir);
       return {
         content: [{ type: "text", text: result.message }],

package/src/pi/ui.ts

@@ -4,10 +4,27 @@ import type { AgentRun } from "../schemas/findings.ts";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { activeTask } from "../state/persistence.ts";
 import { detectProjectRoot } from "../state/project.ts";
-import { advanceExpression, anyPlaying, createExpression, FAST_TICK_MS, type ExpressionState } from "./expressions.ts";
-import { SLOT_IDS } from "./mascot-art.ts";
+import {
+  advanceExpression,
+  anyPlaying,
+  createExpression,
+  expressionPhase,
+  FAST_TICK_MS,
+  ORACLE_GAP,
+  SLOT_GAP,
+  talkFrame,
+  triggerEmote,
+  WORKING_BLINK_CHANCE,
+  WORKING_GAP,
+  type ExpressionGap,
+  type ExpressionState,
+} from "./expressions.ts";
+import { ORACLE_THINKING } from "./activity.ts";
+import { SLOT_IDS, type SlotId } from "./mascot-art.ts";
+import { slotSituations } from "./zen-metrics.ts";
+import type { Situation } from "./kaomoji.ts";
 import { isQuiet, isSubagentProcess, toggleQuiet } from "./quiet.ts";
-import { panelLines, type ExpressionFrames } from "./zen.ts";
+import { panelLines, type ExpressionFrames, type OracleMotion } from "./zen.ts";
 
 export const STATUS_KEY = "bot-lobby";
 
@@ -48,12 +65,18 @@ function touch(): void {
 }
 
 /** Record the master's current activity word (see events.ts); undefined means it waits on the user. */
-export function setOracleActivity(activity: string | undefined): void {
+export function setOracleActivity(activity: string | undefined, now = Date.now()): void {
   if (activity === oracleActivity) return;
   oracleActivity = activity;
+  // The oracle speaks when it names something new, including handing you the turn;
+  // quietly going back to "thinking" between tool calls is not worth a word.
+  if (activity !== ORACLE_THINKING) oracleSpokeAt = now;
   touch();
 }
 
+/** When the oracle last said something new; its mouth lip-syncs for `TALK_MS` after. */
+let oracleSpokeAt: number | undefined;
+
 /** Upper bound on retained runs so a long task cannot grow the widget state without limit. */
 export const MAX_RETAINED_RUNS = 128;
 
@@ -131,9 +154,9 @@ function liveTickDelay(): number {
   return isLive() ? LIVE_TICK_MS : IDLE_TICK_MS;
 }
 
-/** Tick delay for the zen clock: fastest while an expression plays, so no blink or emote step is skipped. */
-export function expressionTickDelay(states: readonly ExpressionState[], now: number, live: boolean): number {
-  if (anyPlaying(states, now)) return FAST_TICK_MS;
+/** Tick delay for the zen clock: fastest while an expression plays or the oracle talks, so no step is skipped. */
+export function expressionTickDelay(states: readonly ExpressionState[], now: number, live: boolean, talking = false): number {
+  if (talking || anyPlaying(states, now)) return FAST_TICK_MS;
   return live ? LIVE_TICK_MS : IDLE_TICK_MS;
 }
 
@@ -141,6 +164,33 @@ export function expressionTickDelay(states: readonly ExpressionState[], now: num
 type ExpressionKey = keyof ExpressionFrames;
 const EXPRESSION_KEYS: readonly ExpressionKey[] = [...SLOT_IDS, "oracle"];
 
+/** The oracle keeps its own schedule; working agents are livelier than idle ones. */
+function gapFor(key: ExpressionKey, situations?: Record<SlotId, Situation>): ExpressionGap {
+  if (key === "oracle") return ORACLE_GAP;
+  return situations?.[key].status === "working" ? WORKING_GAP : SLOT_GAP;
+}
+
+function blinkChanceFor(key: ExpressionKey, situations?: Record<SlotId, Situation>): number | undefined {
+  return key !== "oracle" && situations?.[key].status === "working" ? WORKING_BLINK_CHANCE : undefined;
+}
+
+/** A compact fingerprint of what a slot is going through; a change may earn a reaction. */
+export function situationKey(situation: Situation): string {
+  return [situation.status, situation.flag ?? "", situation.handover ? "handover" : "", situation.wrappedUp ? "wrapped" : ""].join("|");
+}
+
+/**
+ * Whether a slot's change of situation deserves an immediate emote: it started
+ * work, finished, failed, got flagged (waiting, quiet, retrying) or received a
+ * file. Going idle, or a flag clearing, passes quietly.
+ */
+export function isReaction(previous: string | undefined, next: Situation): boolean {
+  if (previous === undefined || previous === situationKey(next)) return false;
+  if (next.status === "idle") return false;
+  if (next.status !== "working") return true;
+  return !previous.startsWith("working|") || next.flag !== undefined || next.handover === true;
+}
+
 /** Animated zen scene + plan checklist shown above the editor while a task is active. */
 class ZenWidget implements Component {
   private tick = 0;
@@ -149,6 +199,7 @@ class ZenWidget implements Component {
   private timer: ReturnType<typeof setInterval>;
   private disposed = false;
   private readonly expressions: Record<ExpressionKey, ExpressionState>;
+  private readonly situations: Partial<Record<SlotId, string>> = {};
   private readonly tui: TUI;
   private readonly theme: () => Theme;
   private readonly rng: () => number;
@@ -158,7 +209,7 @@ class ZenWidget implements Component {
     this.theme = theme;
     this.rng = rng;
     const now = Date.now();
-    const entries = EXPRESSION_KEYS.map((key) => [key, createExpression(now, rng)] as const);
+    const entries = EXPRESSION_KEYS.map((key) => [key, createExpression(now, rng, gapFor(key))] as const);
     this.expressions = Object.fromEntries(entries) as Record<ExpressionKey, ExpressionState>;
     this.timer = setInterval(() => this.advance(), this.delay);
     mountedWidget = this;
@@ -179,22 +230,38 @@ class ZenWidget implements Component {
   }
 
   private play(now: number): void {
-    for (const key of EXPRESSION_KEYS) this.expressions[key] = advanceExpression(this.expressions[key], now, this.rng);
+    const situations = slotSituations(zenState.runs, now);
+    for (const key of EXPRESSION_KEYS) {
+      this.expressions[key] = advanceExpression(this.expressions[key], now, this.rng, gapFor(key, situations), blinkChanceFor(key, situations));
+    }
+    for (const id of SLOT_IDS) {
+      const situation = situations[id];
+      if (isReaction(this.situations[id], situation)) this.expressions[id] = triggerEmote(now, this.rng, gapFor(id, situations));
+      this.situations[id] = situationKey(situation);
+    }
   }
 
   /** One interval, retimed when work starts or stops or an expression plays. */
   private retime(now: number): void {
-    const delay = expressionTickDelay(Object.values(this.expressions), now, isLive());
+    const delay = expressionTickDelay(Object.values(this.expressions), now, isLive(), talkFrame(oracleSpokeAt, now) !== undefined);
     if (delay === this.delay) return;
     this.delay = delay;
     clearInterval(this.timer);
     this.timer = setInterval(() => this.advance(), delay);
   }
 
+  private motion(now: number): OracleMotion {
+    return { phase: expressionPhase(this.expressions.oracle, now), talk: talkFrame(oracleSpokeAt, now) };
+  }
+
   private frames(): Partial<Record<ExpressionKey, number>> {
     return Object.fromEntries(EXPRESSION_KEYS.map((key) => [key, this.expressions[key].frame]));
   }
 
+  private variants(): Partial<Record<SlotId, number>> {
+    return Object.fromEntries(SLOT_IDS.map((id) => [id, this.expressions[id].variant]));
+  }
+
   /**
    * The panel only changes with the tick, an expression frame, the widget state or
    * the elapsed second, so every other repaint (typing in the editor, streaming
@@ -206,10 +273,12 @@ class ZenWidget implements Component {
     const theme = this.theme();
     const expressions = this.frames();
     const quiet = isQuiet();
-    const frameKey = EXPRESSION_KEYS.map((key) => expressions[key] ?? 0).join(",");
-    const key = `${width}|${rows}|${this.tick}|${frameKey}|${zenVersion}|${Math.floor(now / 1000)}|${quiet}`;
+    const variants = this.variants();
+    const frameKey = [...EXPRESSION_KEYS.map((key) => expressions[key] ?? 0), ...SLOT_IDS.map((id) => variants[id] ?? 0)].join(",");
+    const motion = this.motion(now);
+    const key = `${width}|${rows}|${this.tick}|${frameKey}|${motion.phase}|${motion.talk}|${zenVersion}|${Math.floor(now / 1000)}|${quiet}`;
     if (this.cache && this.cache.key === key && this.cache.theme === theme) return this.cache.lines;
-    const opts = { width, rows, tick: this.tick, theme, expressions, oracleActivity };
+    const opts = { width, rows, tick: this.tick, theme, expressions, variants, oracleActivity, oracleMotion: motion };
     const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => truncateToWidth(line, width));
     this.cache = { key, theme, lines };
     return lines;